@schlenkr/ragents 0.1.8 → 0.1.9

package/packages/workspace-executor/src/language-server/roots.ts

@@ -22,8 +22,3 @@ export const resolveRootDirectory = async (workspaceRoot: string, requested: str
   if (!info?.isDirectory()) throw new Error(`${requested} ist kein Verzeichnis im Arbeitsverzeichnis`);
   return absolute;
 };
-
-export const dotnetCommand = (server: string, args: readonly string[]): { command: string; args: string[] } =>
-  server.toLowerCase().endsWith(".dll")
-    ? { command: "dotnet", args: [server, ...args] }
-    : { command: server, args: [...args] };

package/packages/workspace-executor/src/modules.ts

@@ -1,7 +1,6 @@
-import { browserModule } from "./browser/module.js";
 import { commandModule } from "./commands.js";
+import type { WorkspaceExecutorParts } from "./contributions.js";
 import { fileModule } from "./files.js";
-import { workspaceLanguageServers } from "./language-server/adapters/index.js";
 import { languageServerModule } from "./language-server/module.js";
 import type { WorkspaceModuleFactory } from "./module.js";
 import { processModule } from "./processes/module.js";
@@ -11,15 +10,17 @@ import { sandboxToolsModule } from "./sandbox-tools.js";
 export interface WorkspaceExecutorModuleOptions {
   /** Der neue Ordner eines Runs auf dieser Maschine; nur ein Arbeitsplatz kennt ihn, auf dem Server legt ihn der Host an. */
   runFolder?: (runId: string) => string;
+  /** Die Beiträge der Plugins, gebaut für diese Maschine; Server und Arbeitsplatz bekommen dieselben. */
+  contributions: readonly WorkspaceExecutorParts[];
 }
 
-/** Die Module jedes Executors, im Server wie auf dem Arbeitsplatz dieselben. */
-export const workspaceExecutorModules = (options: WorkspaceExecutorModuleOptions = {}): readonly WorkspaceModuleFactory[] => [
+/** Die Module eines Executors: die eigenen und was die Beiträge der Plugins hinzufügen. */
+export const workspaceExecutorModules = (options: WorkspaceExecutorModuleOptions): readonly WorkspaceModuleFactory[] => [
   sandboxToolsModule,
-  languageServerModule(workspaceLanguageServers),
+  languageServerModule(options.contributions.flatMap((parts) => parts.languageServers ?? [])),
   fileModule,
   processModule(),
   commandModule(),
-  browserModule(),
+  ...options.contributions.flatMap((parts) => parts.modules ?? []),
   runFolderModule(options.runFolder),
 ];

package/packages/workspace-executor/src/sandbox-tools.ts

@@ -40,11 +40,6 @@ export interface SandboxTools {
   shutdown: () => Promise<void>;
 }
 
-export const DEFAULT_BASH_TIMEOUT_SECONDS = (() => {
-  const value = Number(process.env.RAGENTS_BASH_TIMEOUT_SECONDS);
-  return Number.isFinite(value) && value > 0 ? value : 600;
-})();
-
 type ToolResult = { content?: Array<{ type: string; text?: string }>; details?: unknown };
 
 /** Der Stand einer Datei, den das Modell zuletzt gesehen hat; der Host führt ihn je Actor und gibt ihn mit, das Modell nennt ihn nie. */
@@ -269,7 +264,7 @@ export const createSandboxTools = async (
       const context = await contextFor();
       if (shuttingDown) throw new Error("Die Werkzeuge werden killed");
       options.signal?.throwIfAborted();
-      const bash = bashLaunch(context.bash, command, context.env);
+      const bash = bashLaunch({ bash: context.bash, rg: context.rg }, command, context.env);
       const launch = await sandboxedLaunch(context, bash);
       if (shuttingDown) throw new Error("Die Werkzeuge werden killed");
       options.signal?.throwIfAborted();
@@ -303,11 +298,10 @@ export const createSandboxTools = async (
             }
           });
         };
-        const timeoutSeconds = options.timeout ?? DEFAULT_BASH_TIMEOUT_SECONDS;
         const timer = setTimeout(() => {
           timedOut = true;
           kill();
-        }, timeoutSeconds * 1000);
+        }, options.timeout * 1000);
         options.signal?.addEventListener("abort", kill);
         const cleanup = () => {
           if (timer) clearTimeout(timer);
@@ -322,7 +316,7 @@ export const createSandboxTools = async (
           const finish = () => processError
             ? reject(processError)
             : timedOut
-              ? reject(new Error(`timeout:${timeoutSeconds}`))
+              ? reject(new Error(`timeout:${options.timeout}`))
               : resolve({ exitCode: killed ? null : code });
           if (!child.pid) {
             finish();

package/packages/workspace-executor/src/shell-platform.ts

@@ -1,11 +1,22 @@
 const platformTexts: Partial<Record<NodeJS.Platform, string>> = {
-  darwin: "`bash` runs on macOS with the BSD userland: `grep` has no `-P` (use `grep -E` or `rg`), in-place `sed` needs an explicit backup suffix (`sed -i '' ...`), `date` uses `-v` instead of `-d`, `xargs` uses `-I{}` instead of `-i`, and other GNU-only flags are unavailable. `/bin/bash` is version 3.2: no associative arrays (`declare -A`), no `mapfile`/`readarray`, no `${var,,}` case conversion.",
+  darwin: "`bash` runs on macOS with the BSD userland: `grep` has no `-P` (use `grep -E`), in-place `sed` needs an explicit backup suffix (`sed -i '' ...`), `date` uses `-v` instead of `-d`, `xargs` uses `-I{}` instead of `-i`, and other GNU-only flags are unavailable. `/bin/bash` is version 3.2: no associative arrays (`declare -A`), no `mapfile`/`readarray`, no `${var,,}` case conversion.",
   linux: "`bash` runs on Linux with the GNU userland: `grep -P`, `sed -i` without suffix and the usual GNU flags work.",
   win32: "`bash` runs on Windows with the bash RAgents brings along, an MSYS userland with the GNU tools (coreutils, `grep`, `sed`, `awk`, `find`, `xargs`, `diff`, `patch`, `tar`, `gzip`, `unzip`, `file`, `cygpath`, `dos2unix`): `grep -P`, `sed -i` without suffix and the usual GNU flags work. `git`, `dotnet` and `node` are the Windows programs of this machine on the `PATH`, with the user's own configuration and login; they take Windows paths, not `/c/...` (`cygpath -w` converts). The file system is the Windows one: absolute paths are `C:/project/...` or `/c/project/...`, both spellings reach the same file, and a path from another tool may use backslashes. Files often carry CRLF line endings, so anchor patterns with `\\r\\?$` and keep the line ending a file already has.",
 };
 
-export const shellPlatformText = (platform: NodeJS.Platform = process.platform): string => {
+const searchTexts = {
+  ripgrep: "Search code with `rg` (ripgrep) and list files with `rg --files`: it skips hidden files and everything `.gitignore` excludes, such as `node_modules`, `bin` and `obj`, and is far faster than `grep -r` (`rg -uu` searches those too). Use `grep` only on single files or in pipes.",
+  grep: "`rg` (ripgrep) is not available here. `grep -r` also walks dependency and build folders, so exclude them: `grep -r --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=bin --exclude-dir=obj ...`.",
+};
+
+/** Was der Executor dem Werkzeug bash über die Plattform hinaus bietet. */
+export interface ShellTools {
+  readonly ripgrep: boolean;
+}
+
+export const shellPlatformText = (platform: NodeJS.Platform, tools: ShellTools): string => {
   const text = platformTexts[platform];
   if (!text) throw new Error(`Für die Plattform ${platform} gibt es keine Shell-Beschreibung.`);
-  return `${text} A nonzero exit code, for example \`grep\` without a match, comes back as an ordinary result with the code at the end, not as a tool error; only start, timeout and abort problems are tool errors.`;
+  const search = tools.ripgrep ? searchTexts.ripgrep : searchTexts.grep;
+  return `${text} ${search} A nonzero exit code, for example \`grep\` without a match, comes back as an ordinary result with the code at the end, not as a tool error; only start, timeout and abort problems are tool errors.`;
 };

package/packages/workspace-executor/src/tools.ts

@@ -23,6 +23,3 @@ export const workspaceDataDirectory = (home = homedir()): string => path.join(ra
 /** Der Datenordner dieses Prozesses: DATA_DIR wie beim Server, sonst der des Arbeitsplatzes ohne Profil. */
 export const hostDataDirectory = (environment: NodeJS.ProcessEnv = process.env): string =>
   path.resolve(environment.DATA_DIR ?? workspaceDataDirectory());
-
-export const hostToolFile = (pluginId: string, relative: string): string =>
-  path.join(pluginToolsDirectory(hostDataDirectory(), pluginId), ...relative.split("/"));

package/plugins/ragents.ask/ask-payload.ts

@@ -1,5 +1,8 @@
 export const ASK_PLUGIN_ID = "ragents.ask";
 
+/** What the asking tool call gets when a person's message to the asker closes its question. */
+export const SUPERSEDED_ANSWER = "Not answered: the user sent a new message instead.";
+
 export interface AskPayload {
   question: string;
   options: string[];
@@ -23,3 +26,9 @@ export const askPayloadOf = (payload: unknown): AskPayload | undefined => {
     ...(typeof candidate.recipient === "string" ? { recipient: candidate.recipient } : {}),
   };
 };
+
+export const supersedingInputOf = (result: unknown): string | undefined => {
+  if (typeof result !== "object" || result === null) return undefined;
+  const { supersededBy } = result as { supersededBy?: unknown };
+  return typeof supersededBy === "string" ? supersededBy : undefined;
+};

package/plugins/ragents.ask/server/ask-service.ts

@@ -4,20 +4,34 @@ import {
   type Action,
   type CommandContext,
   type JournalEvent,
+  type JsonValue,
   type Orchestration,
 } from "@ragents/engine";
-import { askPayloadOf, ASK_PLUGIN_ID } from "../ask-payload.js";
+import { askPayloadOf, ASK_PLUGIN_ID, SUPERSEDED_ANSWER, supersedingInputOf } from "../ask-payload.js";
 import { DISMISSED_ANSWER, type AskCall, type AskRequest, type AskService } from "./contract.js";
 
 const answerOf = (decision: "approved" | "dismissed", result: unknown): string =>
-  decision !== "approved" ? DISMISSED_ANSWER : typeof result === "string" ? result : result === null || result === undefined ? "" : JSON.stringify(result);
+  decision !== "approved"
+    ? supersedingInputOf(result) === undefined ? DISMISSED_ANSWER : SUPERSEDED_ANSWER
+    : typeof result === "string" ? result : result === null || result === undefined ? "" : JSON.stringify(result);
 
 const resolvedAnswerOf = (action: Action): string | null =>
   action.status === "pending" ? null : answerOf(action.status, action.result);
 
+const humanInputPendingFor = (runtime: Orchestration, runId: string, actorId: string): boolean =>
+  [...runtime.state(runId).inputs.values()].some((input) =>
+    input.actorId === actorId && input.origin === "human" && input.lifecycle.kind === "pending");
+
+interface Waiter {
+  runId: string;
+  /** The actor whose running turn waits for the answer; null for a question asked outside a turn. */
+  blockedActorId: string | null;
+  settle: (answer: string) => void;
+}
+
 export class RuntimeAskService implements AskService {
   #runtime: Orchestration | undefined;
-  readonly #waiters = new Map<string, (answer: string) => void>();
+  readonly #waiters = new Map<string, Waiter>();
   readonly #aborting = new Set<string>();
 
   bind(runtime: Orchestration): void {
@@ -28,6 +42,7 @@ export class RuntimeAskService implements AskService {
 
   ask(call: AskCall, request: AskRequest, signal: AbortSignal | undefined): Promise<string> {
     const runtime = this.#requireRuntime();
+    if (call.turnId && humanInputPendingFor(runtime, call.runId, call.agentId)) return Promise.resolve(SUPERSEDED_ANSWER);
     const context: CommandContext = {
       actorId: call.agentId,
       commandId: call.commandId,
@@ -51,7 +66,7 @@ export class RuntimeAskService implements AskService {
     if (proposed?.type !== "action.proposed") {
       throw new Error(`Die Frage von ${call.agentId} wurde nicht im Journal von ${call.runId} angelegt`);
     }
-    return this.#awaitAnswer(call.runId, proposed.payload.actionId, signal);
+    return this.#awaitAnswer(call.runId, proposed.payload.actionId, call.turnId ? call.agentId : null, signal);
   }
 
   answer(runId: string, actionId: string, input: { answer?: string; dismiss?: boolean }): void {
@@ -72,6 +87,18 @@ export class RuntimeAskService implements AskService {
   }
 
   withdraw(runId: string, actionId: string): void {
+    this.#dismiss(runId, actionId, "ask-withdraw", null, DISMISSED_ANSWER);
+  }
+
+  #supersede(runId: string, actionId: string, inputId: string): void {
+    try {
+      this.#dismiss(runId, actionId, "ask-supersede", { supersededBy: inputId }, SUPERSEDED_ANSWER);
+    } catch (error) {
+      console.error(`Question ${actionId} could not be closed for message ${inputId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  #dismiss(runId: string, actionId: string, commandPrefix: string, result: JsonValue, answer: string): void {
     const runtime = this.#requireRuntime();
     const state = runtime.state(runId);
     const action = state.actions.get(actionId);
@@ -79,18 +106,18 @@ export class RuntimeAskService implements AskService {
     this.#aborting.add(actionId);
     try {
       runtime.resolveAction(
-        { actorId: state.ownerId, commandId: `ask-withdraw:${actionId}:${randomUUID()}` },
+        { actorId: state.ownerId, commandId: `${commandPrefix}:${actionId}:${randomUUID()}` },
         runId,
         actionId,
-        { decision: "dismissed", result: null },
+        { decision: "dismissed", result },
       );
     } finally {
       this.#aborting.delete(actionId);
     }
-    this.#waiters.get(actionId)?.(DISMISSED_ANSWER);
+    this.#waiters.get(actionId)?.settle(answer);
   }
 
-  #awaitAnswer(runId: string, actionId: string, signal: AbortSignal | undefined): Promise<string> {
+  #awaitAnswer(runId: string, actionId: string, blockedActorId: string | null, signal: AbortSignal | undefined): Promise<string> {
     const runtime = this.#requireRuntime();
     const action = runtime.state(runId).actions.get(actionId);
     if (!action) throw new Error(`Frage ${actionId} existiert nicht in Run ${runId}`);
@@ -123,16 +150,29 @@ export class RuntimeAskService implements AskService {
         return;
       }
       signal?.addEventListener("abort", abort, { once: true });
-      this.#waiters.set(actionId, (answer) => {
-        signal?.removeEventListener("abort", abort);
-        this.#waiters.delete(actionId);
-        resolve(answer);
+      this.#waiters.set(actionId, {
+        runId,
+        blockedActorId,
+        settle: (answer) => {
+          signal?.removeEventListener("abort", abort);
+          this.#waiters.delete(actionId);
+          resolve(answer);
+        },
       });
     });
   }
 
   #onJournal(events: JournalEvent[]): void {
     for (const event of events) {
+      if (event.type === "actor.input.enqueued") {
+        if (event.payload.origin !== "human") continue;
+        const { actorId, inputId } = event.payload;
+        for (const [actionId, waiter] of this.#waiters) {
+          if (waiter.runId !== event.runId || waiter.blockedActorId !== actorId) continue;
+          queueMicrotask(() => this.#supersede(event.runId, actionId, inputId));
+        }
+        continue;
+      }
       if (event.type !== "action.resolved") continue;
       if (this.#aborting.has(event.payload.actionId)) continue;
       const resolved = this.#requireRuntime().state(event.runId).actions.get(event.payload.actionId);
@@ -140,7 +180,7 @@ export class RuntimeAskService implements AskService {
       const answer = answerOf(event.payload.decision, event.payload.result);
       const waiter = this.#waiters.get(event.payload.actionId);
       if (waiter) {
-        waiter(answer);
+        waiter.settle(answer);
         continue;
       }
       queueMicrotask(() => this.#enqueueAnswer(event.runId, event.payload.actionId, answer));

package/plugins/ragents.ask/web/AskActionView.tsx

@@ -1,7 +1,7 @@
 import { useAccess } from "@ragents/web/AccessContext";
 import { useState } from "react";
 import type { ActionViewContext } from "@ragents/web/PluginRegistry";
-import { askPayloadOf } from "../ask-payload";
+import { askPayloadOf, SUPERSEDED_ANSWER, supersedingInputOf } from "../ask-payload";
 import { answerQuestion } from "./api";
 import { QuestionCard } from "./QuestionCard";
 
@@ -25,7 +25,8 @@ export function AskActionView({ action, session, text }: ActionViewContext) {
       <QuestionCard
         answer={action.status === undefined
           ? undefined
-          : action.status === "approved" ? answerTextOf(action.result) : "Der Benutzer hat die Frage verworfen."}
+          : action.status === "approved" ? answerTextOf(action.result)
+          : supersedingInputOf(action.result) !== undefined ? SUPERSEDED_ANSWER : "Der Benutzer hat die Frage verworfen."}
         onAnswer={access.can("runs.write") ? answer : undefined}
         question={question}
         text={text}

package/plugins/ragents.browser/executor/index.ts

@@ -0,0 +1,5 @@
+import type { WorkspaceExecutorContribution } from "@ragents/workspace-executor";
+import { browserModule } from "./module.js";
+
+/** Der Browser läuft dort, wo der Arbeitsbereich des Runs liegt: im Executor des Servers oder in dem des Arbeitsplatzes. */
+export const executor: WorkspaceExecutorContribution = (machine) => ({ modules: [browserModule(machine)] });

package/{packages/workspace-executor/src/browser → plugins/ragents.browser/executor}/module.ts

@@ -1,6 +1,5 @@
 import type { Browser } from "playwright-core";
-import { WorkspaceOperationError } from "../errors.js";
-import type { WorkspaceModuleFactory } from "../module.js";
+import type { WorkspaceExecutorMachine, WorkspaceModuleFactory } from "@ragents/workspace-executor";
 import { BROWSER_OPERATIONS, type BrowserCheck, type BrowserTarget, type BrowserViewport } from "./contract.js";
 import { BrowserPages } from "./pages.js";
 import { launchChromium } from "./playwright.js";
@@ -14,38 +13,33 @@ export interface BrowserModuleOptions {
   checkTimeoutMs?: number;
 }
 
-const invalid = (message: string): WorkspaceOperationError => new WorkspaceOperationError("browser-input-invalid", message, 400);
-
-const fieldsOf = (input: unknown): Readonly<Record<string, unknown>> => {
-  if (typeof input !== "object" || input === null || Array.isArray(input)) throw invalid("Die Eingabe einer Browseroperation ist ein Objekt");
-  return input as Readonly<Record<string, unknown>>;
-};
-
-const textOf = (input: unknown, key: string): string => {
-  const value = fieldsOf(input)[key];
-  if (typeof value !== "string") throw invalid(`Die Browseroperation braucht ${key} als Text`);
-  return value;
-};
-
-const targetOf = (input: unknown): BrowserTarget => {
-  const value = fieldsOf(input).target;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) throw invalid("Die Browseroperation braucht ein Ziel");
-  return value as BrowserTarget;
-};
-
-const viewportOf = (input: unknown): BrowserViewport => {
-  const { width, height } = fieldsOf(input);
-  if (typeof width !== "number" || typeof height !== "number" || !Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
-    throw invalid("Ein Viewport braucht Breite und Höhe als positive ganze Zahlen");
-  }
-  return { width, height };
-};
-
 /** Der Browser eines Runs auf dieser Maschine: Seite, Aktionen, Prüfungen und Aufnahmen; Evidenz und Ablage hält der Aufrufer. */
-export const browserModule = (options: BrowserModuleOptions = {}): WorkspaceModuleFactory => (host) => {
+export const browserModule = (machine: WorkspaceExecutorMachine, options: BrowserModuleOptions = {}): WorkspaceModuleFactory => (host) => {
+  const invalid = (message: string): Error => machine.operationError("browser-input-invalid", message, 400);
+  const fieldsOf = (input: unknown): Readonly<Record<string, unknown>> => {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) throw invalid("Die Eingabe einer Browseroperation ist ein Objekt");
+    return input as Readonly<Record<string, unknown>>;
+  };
+  const textOf = (input: unknown, key: string): string => {
+    const value = fieldsOf(input)[key];
+    if (typeof value !== "string") throw invalid(`Die Browseroperation braucht ${key} als Text`);
+    return value;
+  };
+  const targetOf = (input: unknown): BrowserTarget => {
+    const value = fieldsOf(input).target;
+    if (typeof value !== "object" || value === null || Array.isArray(value)) throw invalid("Die Browseroperation braucht ein Ziel");
+    return value as BrowserTarget;
+  };
+  const viewportOf = (input: unknown): BrowserViewport => {
+    const { width, height } = fieldsOf(input);
+    if (typeof width !== "number" || typeof height !== "number" || !Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
+      throw invalid("Ein Viewport braucht Breite und Höhe als positive ganze Zahlen");
+    }
+    return { width, height };
+  };
   const timeoutMs = options.timeoutMs ?? BROWSER_TIMEOUT_MS;
   const pages = new BrowserPages({
-    launch: options.launch ?? (async (runId) => launchChromium((await host.contextFor(runId)).hostRoot, runId, timeoutMs)),
+    launch: options.launch ?? (async (runId) => launchChromium(machine, (await host.contextFor(runId)).hostRoot, runId, timeoutMs)),
     timeoutMs,
     checkTimeoutMs: options.checkTimeoutMs ?? Math.min(5_000, timeoutMs),
   });

package/{packages/workspace-executor/src/browser → plugins/ragents.browser/executor}/playwright.ts

@@ -1,30 +1,16 @@
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { homedir } from "node:os";
-import path from "node:path";
+import { pathToFileURL } from "node:url";
 import type { Browser } from "playwright-core";
-import { RUN_MARKER_ENV } from "../run-marker.js";
-import { safeProcessEnvironment } from "../safe-environment.js";
+import type { WorkspaceExecutorMachine } from "@ragents/workspace-executor";
 import { BROWSER_EXECUTABLE_VARIABLE } from "./contract.js";
 
 type Playwright = typeof import("playwright-core");
 
-const messageOf = (cause: unknown): string => cause instanceof Error ? cause.message : String(cause);
-
-/** playwright-core liegt in den node_modules des Hosts dieser Maschine und wird erst im Aufruf geladen, nie mit dem Executor. */
-export const hostPlaywright = (hostRoot: string | undefined): Playwright => {
-  if (!hostRoot) {
-    throw new Error("Für die Browserprüfung ist auf diesem Rechner kein Host bekannt, aus dem sich playwright-core auflösen "
-      + "ließe. Ein Arbeitsplatz bekommt ihn mit der ersten Verbindung zu einem verteilenden Server oder über die "
-      + "Einstellung ragents.hostPath");
-  }
-  const load = createRequire(path.join(hostRoot, "package.json"));
-  try {
-    return load("playwright-core") as Playwright;
-  } catch (cause) {
-    throw new Error(`playwright-core liegt nicht im Host ${hostRoot}: ${messageOf(cause)}`);
-  }
+/** playwright-core liegt in den node_modules des Hosts dieser Maschine und wird erst im Aufruf geladen, nie mit dem Beitrag. */
+export const hostPlaywright = async (machine: WorkspaceExecutorMachine, hostRoot: string | undefined): Promise<Playwright> => {
+  const loaded = await import(pathToFileURL(machine.hostPackageFile(hostRoot, "playwright-core")).href) as { default: Playwright };
+  return loaded.default;
 };
 
 /** Der Chrome dieser Maschine: der aus ihrer Umgebung, sonst das Chromium, das die Provisionierung für playwright-core holt. */
@@ -41,12 +27,12 @@ export const browserExecutable = async (playwright: Playwright, environment: Nod
 };
 
 /** Startet Chrome headless mit der Umgebung dieser Maschine und dem Marker des Runs, damit die Prozessanzeige ihn zuordnet. */
-export const launchChromium = async (hostRoot: string | undefined, runId: string, timeoutMs: number): Promise<Browser> => {
-  const playwright = hostPlaywright(hostRoot);
+export const launchChromium = async (machine: WorkspaceExecutorMachine, hostRoot: string | undefined, runId: string, timeoutMs: number): Promise<Browser> => {
+  const playwright = await hostPlaywright(machine, hostRoot);
   return playwright.chromium.launch({
     executablePath: await browserExecutable(playwright),
     headless: true,
     timeout: timeoutMs,
-    env: { ...safeProcessEnvironment(process.env), HOME: homedir(), [RUN_MARKER_ENV]: runId },
+    env: machine.processEnvironment(runId),
   });
 };

package/plugins/ragents.browser/provision.ts

@@ -2,13 +2,13 @@ import { spawn } from "node:child_process";
 import { access, constants } from "node:fs/promises";
 import path from "node:path";
 import { chromium } from "playwright-core";
-import { BROWSER_EXECUTABLE_VARIABLE } from "@ragents/workspace-executor";
 import {
   hostPackageFolder,
   provisionGap,
   provisionReady,
   type PluginProvision,
 } from "@ragents/host/plugin-support/provision.js";
+import { BROWSER_EXECUTABLE_VARIABLE } from "./executor/contract.js";
 
 const executable = async (file: string): Promise<boolean> => access(file, constants.X_OK).then(() => true, () => false);
 

package/plugins/ragents.browser/server/browser.ts

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
+import type { SandboxServices } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
+import { documentsApiPrefix } from "@ragents/plugins/ragents.documents/contract.js";
 import {
   BROWSER_OPERATIONS,
   type BrowserCheck,
@@ -10,9 +12,7 @@ import {
   type BrowserStep,
   type BrowserTarget,
   type BrowserViewport,
-} from "@ragents/workspace-executor";
-import type { SandboxServices } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
-import { documentsApiPrefix } from "@ragents/plugins/ragents.documents/contract.js";
+} from "../executor/contract.js";
 import type { BrowserCallOptions, BrowserEvidence, BrowserRuntime } from "./contract.js";
 
 export const DEFAULT_VIEWPORT: BrowserViewport = { width: 1920, height: 1080 };

package/plugins/ragents.browser/server/contract.ts

@@ -1,7 +1,7 @@
 import { serviceToken } from "@ragents/engine";
-import type { BrowserSnapshot } from "@ragents/workspace-executor";
+import type { BrowserSnapshot } from "../executor/contract.js";
 
-export type { BrowserSnapshot, BrowserTarget } from "@ragents/workspace-executor";
+export type { BrowserSnapshot, BrowserTarget } from "../executor/contract.js";
 
 export interface BrowserEvidence {
   checkedAt?: string;

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

@@ -1,8 +1,8 @@
 import type { RAgentsPlugin } from "@ragents/engine";
-import { BROWSER_EXECUTABLE_VARIABLE } from "@ragents/workspace-executor";
 import type { PluginModule } from "@ragents/host/plugin-support/plugin-module.js";
 import { sandboxServicesToken } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
 import { documentStoreToken } from "@ragents/host/ragents/document-store.js";
+import { BROWSER_EXECUTABLE_VARIABLE } from "../executor/contract.js";
 import { RunBrowser } from "./browser.js";
 import { browserRuntimeToken } from "./contract.js";
 import { createBrowserFunctions, createBrowserImageContribution } from "./tools.js";

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

@@ -0,0 +1,80 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import type { LanguageServerDescription, WorkspaceExecutorContribution } from "@ragents/workspace-executor";
+
+export const FSHARP_SERVER_VARIABLE = "FSHARP_LANGUAGE_SERVER";
+export const FSHARP_SERVER_FILE = "fsautocomplete/fsautocomplete.dll";
+
+const languages = { ".fs": "fsharp", ".fsi": "fsharp", ".fsx": "fsharp" } as const;
+
+export const fsharpLanguageServer: LanguageServerDescription = {
+  id: "fsharp",
+  label: "FSAC",
+  languages,
+  rootDescription: "the .sln file (or a single .fsproj)",
+};
+
+const PROJECT_LINE = /^Project\("\{[^}]+\}"\)\s*=\s*"[^"]*",\s*"([^"]+)"/gm;
+
+/** Die Projekte einer .sln, aufgelöst neben ihr; Ordnereinträge der Solution zählen nicht. */
+export const solutionProjects = async (solutionFile: string): Promise<string[]> => {
+  const text = await readFile(solutionFile, "utf8");
+  const directory = path.dirname(solutionFile);
+  return [...text.matchAll(PROJECT_LINE)]
+    .map((match) => match[1].replaceAll("\\", "/"))
+    .filter((relative) => /\.[a-z]+proj$/i.test(relative))
+    .map((relative) => path.resolve(directory, relative));
+};
+
+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[FSHARP_SERVER_VARIABLE];
+  if (configured) return configured;
+  const provisioned = path.join(toolsDirectory, ...FSHARP_SERVER_FILE.split("/"));
+  if (existsSync(provisioned)) return provisioned;
+  throw new Error("fsautocomplete gibt es auf diesem Rechner nicht: weder "
+    + `${FSHARP_SERVER_VARIABLE} gesetzt noch ${provisioned} vorhanden. Ein Arbeitsplatz holt es mit `
+    + `pnpm provision --workspace, ein Server über pnpm provision <profil>; ${FSHARP_SERVER_VARIABLE} übersteuert beides`);
+};
+
+const contentOf = (params: unknown): string => (params as { content?: string } | undefined)?.content ?? "";
+
+export const executor: WorkspaceExecutorContribution = (machine) => ({
+  languageServers: [{
+    ...fsharpLanguageServer,
+    resolveRoot: (workspaceRoot, root) => machine.resolveRootFile(workspaceRoot, root, [".sln", ".fsproj"]),
+    rootDirectory: (root) => path.dirname(root),
+    launch: async (context, root) => ({
+      label: "FSAC",
+      ...dotnetCommand(serverPath(machine.toolsDirectory), ["--state-directory", path.join(context.logDirectory, "fsautocomplete")]),
+      cwd: path.dirname(root),
+      env: context.env,
+      uid: context.uid,
+      gid: context.gid,
+      rootUri: pathToFileURL(path.dirname(root)).href,
+      initializationOptions: { AutomaticWorkspaceInit: false },
+      languages,
+    }),
+    open: async (session, root, timeoutMs) => {
+      const projects = root.toLowerCase().endsWith(".sln")
+        ? (await solutionProjects(root)).filter((project) => project.toLowerCase().endsWith(".fsproj"))
+        : [root];
+      if (projects.length === 0) throw new Error(`${path.basename(root)} enthält keine F#-Projekte`);
+      const finished = session.waitForNotification(timeoutMs, "Projekte geladen", (method, params) =>
+        method === "fsharp/notifyWorkspace"
+        && contentOf(params).includes("\"workspaceLoad\"")
+        && contentOf(params).includes("\"finished\""));
+      await session.request("fsharp/workspaceLoad", {
+        textDocuments: projects.map((project) => ({ uri: pathToFileURL(project).href })),
+      });
+      await finished;
+      return `${projects.length} F#-Projekt${projects.length === 1 ? "" : "e"} aus ${path.basename(root)} geladen`;
+    },
+  }],
+});

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

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

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

@@ -1,6 +1,6 @@
-import { fsharpAdapter, FSHARP_SERVER_VARIABLE } 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 { fsharpLanguageServer, FSHARP_SERVER_VARIABLE } from "../executor.js";
 
 export const fsharpConfigDescriptors = [
   { key: FSHARP_SERVER_VARIABLE, source: "environment" },
@@ -9,7 +9,7 @@ export const fsharpConfigDescriptors = [
 export const plugin: PluginModule = {
   create: () => createLanguageServerPlugin({
     id: "ragents.lsp-fsharp",
-    adapter: fsharpAdapter,
+    languageServer: fsharpLanguageServer,
     tabLabel: "F#",
     configDescriptors: fsharpConfigDescriptors,
   }),