@schlenkr/ragents 0.1.10 → 0.1.11

package/plugins/ragents.workspace/contract.ts

@@ -16,7 +16,7 @@ export interface BrowseEntry {
 
 export interface BrowseListing {
   root: BrowseRoot;
-  /** Wo die Wurzel liegt; bei einem Arbeitsplatz mit dessen Label. */
+  /** Where the root is; on a workstation with its label. */
   location: string;
   path: string;
   entries: BrowseEntry[];
@@ -31,24 +31,24 @@ export const WORKSPACE_BINDING_OPTION_ID = "ragents.workspace.binding";
 
 export const WORKSPACE_METADATA_ID = "ragents.workspace";
 
-/** Auf welchem Rechner der Arbeitsbereich eines Runs liegt: dem Server oder einem Arbeitsplatz, dessen Label die Bindung festhält. */
+/** On which machine the workspace of a run is: the server or a workstation whose label the binding records. */
 export type WorkspaceMachine = "server" | { client: string; label: string };
 
-/** Ein vorhandener Ordner, den der Run weder anlegt noch löscht. */
+/** An existing folder that the run neither creates nor deletes. */
 export type ExistingWorkspaceFolder = {
   path: string;
 };
 
-/** Der neue Ordner je Run auf einem Arbeitsplatz; seinen Pfad dort hält die Bindung ab dem Wählen fest. */
+/** The new folder per run on a workstation; the binding records its path there from the moment it is chosen. */
 export type FreshWorkstationFolder = {
   path: string;
   fresh: true;
 };
 
-/** Welcher Ordner: ein neuer je Run oder ein vorhandener; `fresh` auf dem Server legt der Host je Run in seiner Ablage an. */
+/** Which folder: a new one per run or an existing one; for `fresh` on the server, the host creates one per run in its storage. */
 export type WorkspaceFolder = "fresh" | ExistingWorkspaceFolder | FreshWorkstationFolder;
 
-/** Wo und in welchem Ordner ein Run arbeitet; wird beim Start als Startoption ins Journal eingefroren. */
+/** Where and in which folder a run works; frozen into the journal as a start option at the start. */
 export type WorkspaceBinding = {
   machine: WorkspaceMachine;
   folder: WorkspaceFolder;
@@ -58,15 +58,15 @@ export const freshServerBinding = (): WorkspaceBinding => ({ machine: "server",
 
 export const WORKSPACE_CLIENT_ID_PATTERN = /^[A-Za-z0-9_-]{8,64}$/;
 
-/** Was ein Arbeitsplatz bei der Anmeldung über sich sagt. */
+/** What a workstation says about itself at sign-in. */
 export interface WorkspaceClientDescription {
   label: string;
   hostname: string;
   platform: string;
   folders: string[];
-  /** Wo der Arbeitsplatz die neuen Ordner je Run anlegt, je Run ein Unterordner mit dessen Kennung. */
+  /** Where the workstation creates the new folders per run, one subfolder per run named with its ID. */
   runsDirectory: string;
-  /** Ob die Bash des Arbeitsplatzes rg findet; der Prompt richtet die Suche danach. */
+  /** Whether the workstation's bash finds rg; the prompt adjusts the search accordingly. */
   ripgrep: boolean;
 }
 
@@ -74,7 +74,7 @@ export interface WorkspaceClientInfo extends WorkspaceClientDescription {
   id: string;
 }
 
-/** Wie der neue Ordner je Run auf jedem Rechner heißt: der leere Ordner oder der Beitrag eines Plugins; null, wo es keinen gibt. */
+/** What the new folder per run is called on each machine: the empty folder or a plugin's contribution; null where there is none. */
 export interface FreshWorkspaceLabels {
   server: string;
   client: string | null;
@@ -84,7 +84,7 @@ export interface WorkspaceBindingPresentation {
   kind: "workspace-binding";
   clients: WorkspaceClientInfo[];
   fresh: FreshWorkspaceLabels;
-  /** Ob ein vorhandener Ordner des Serverrechners gebunden werden darf. */
+  /** Whether an existing folder of the server machine may be bound. */
   serverFolders: boolean;
 }
 
@@ -93,25 +93,25 @@ export interface WorkspaceSessionMetadata {
   summary: string;
 }
 
-const clientId = Type.String({ pattern: "^[A-Za-z0-9_-]{8,64}$", description: "Stabile Kennung des Arbeitsplatzes" });
+const clientId = Type.String({ pattern: "^[A-Za-z0-9_-]{8,64}$", description: "Stable ID of the workstation" });
 
-const executorVersion = Type.String({ minLength: 1, maxLength: 64, description: "Stand des Executors, den der Arbeitsplatz mitbringt" });
+const executorVersion = Type.String({ minLength: 1, maxLength: 64, description: "Version of the executor that the workstation brings" });
 
-/** Die Kennung eines Plugins; ein Arbeitsplatz sucht dessen Bundle unter genau diesem Namen, ein Pfad kann darin nicht stecken. */
+/** The ID of a plugin; a workstation looks for its bundle under exactly this name, so it cannot contain a path. */
 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" });
+  plugin: Type.String({ pattern: PLUGIN_ID_PATTERN.source, maxLength: 128, description: "ID of the plugin" }),
+  stand: Type.String({ pattern: "^[0-9a-f]{64}$", description: "SHA-256 of the contribution file" }),
+}, { additionalProperties: false }), { maxItems: 64, description: "The plugins' contributions to the executor, in the order of the server's plugin list" });
 
 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" }),
+  runsDirectory: Type.String({ minLength: 1, description: "Absolute folder under which the workstation creates the new folders per run" }),
+  ripgrep: Type.Boolean({ description: "Whether the workstation's bash finds rg" }),
 };
 
 export const clientInfoSchema = Type.Object({
@@ -119,7 +119,7 @@ export const clientInfoSchema = Type.Object({
   ...clientDescription,
 }, { additionalProperties: false });
 
-/** Die Anmeldung, wie ein Arbeitsplatz mit dem Executor des Servers sie sendet. */
+/** The sign-in as a workstation with the server's executor sends it. */
 export const clientRegistrationSchema = Type.Object({
   id: clientId,
   ...clientDescription,
@@ -127,53 +127,53 @@ export const clientRegistrationSchema = Type.Object({
   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. */
+/** A workstation with a different executor does not know the shape of this version; the server rejects it by its version, not by its shape. */
 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",
+  description: "Sign-in with a different executor version in any shape; the server rejects it with workspace-executor-version",
 });
 
-const absolutePath = Type.String({ minLength: 1, description: "Absoluter Pfad im gebundenen Ordner" });
+const absolutePath = Type.String({ minLength: 1, description: "Absolute path in the bound folder" });
 
-/** Keine Operation eines Moduls: gibt frei, was der Executor des Arbeitsplatzes für den Run hält. */
+/** Not an operation of a module: releases what the workstation's executor holds for the run. */
 export const WORKSPACE_CLIENT_STOP_OPERATION = "stop";
 
-/** Die eine Operation, die der Server auf dem Arbeitsplatz ruft; Fortschritt ist der JSON-Wert der Operation, bei Bash { text }. */
+/** The one operation the server calls on the workstation; progress is the JSON value of the operation, for bash { text }. */
 export const workspaceClientContracts = {
   execute: defineOperation({
     id: "ragents.workspace.client.execute",
-    description: "Eine Operation des Executors auf dem Arbeitsplatz ausführen, etwa ein Werkzeug, eine Dateiabfrage oder die Prozessanzeige; das Ergebnis ist ihr Wert, Fortschritt ihr JSON-Wert. stop gibt frei, was der Arbeitsplatz für den Run hält.",
+    description: "Run an operation of the executor on the workstation, such as a tool, a file query, or the process display; the result is its value, progress its JSON value. stop releases what the workstation holds for the run.",
     implementedBy: "client",
     input: Type.Object({
-      runId: Type.String({ minLength: 1, maxLength: 64, description: "Kennung des Runs" }),
-      operation: Type.String({ minLength: 1, maxLength: 64, description: "Name der Operation, etwa read, bash, roslyn_open, files.list oder stop" }),
-      toolCallId: Type.Optional(Type.String({ minLength: 1, maxLength: 200, description: "Nur bei einem Werkzeugaufruf des Modells" })),
+      runId: Type.String({ minLength: 1, maxLength: 64, description: "ID of the run" }),
+      operation: Type.String({ minLength: 1, maxLength: 64, description: "Name of the operation, such as read, bash, roslyn_open, files.list, or stop" }),
+      toolCallId: Type.Optional(Type.String({ minLength: 1, maxLength: 200, description: "Only for a tool call of the model" })),
       cwd: absolutePath,
-      env: Type.Record(Type.String(), Type.String(), { description: "Was der Server beiträgt: Run-Marker und Git-Regeln der Sandbox" }),
-      input: Type.Unknown({ description: "Die Eingabe der Operation" }),
+      env: Type.Record(Type.String(), Type.String(), { description: "What the server contributes: run marker and git rules of the sandbox" }),
+      input: Type.Unknown({ description: "The input of the operation" }),
     }, { additionalProperties: false }),
     result: Type.Object({ value: Type.Unknown() }, { additionalProperties: false }),
   }),
 } as const;
 
 const browseTarget = {
-  runId: Type.String({ minLength: 1, maxLength: 64, description: "Kennung des Runs" }),
+  runId: Type.String({ minLength: 1, maxLength: 64, description: "ID of the run" }),
   root: Type.Union([Type.Literal("workspace"), Type.Literal("files")]),
-  path: Type.String({ description: "Pfad unterhalb der Wurzel; leer ist die Wurzel selbst" }),
+  path: Type.String({ description: "Path below the root; empty is the root itself" }),
 };
 
-/** Die Anmeldung eines Arbeitsplatzes bindet die aufrufende Verbindung; über sie ruft der Server zurück. */
+/** The sign-in of a workstation binds the calling connection; the server calls back through it. */
 export const workspaceContracts = {
   browse: {
     list: defineOperation({
       id: "ragents.workspace.browse.list",
-      description: "Ein Verzeichnis im Arbeitsverzeichnis oder in der Dateiablage eines Runs auflisten.",
+      description: "List a directory in the workspace or in the file store of a run.",
       rights: ["runs.read", "runs.inspect"],
       input: Type.Object(browseTarget, { additionalProperties: false }),
       result: openJson<BrowseListing>("BrowseListing"),
     }),
     preview: defineOperation({
       id: "ragents.workspace.browse.preview",
-      description: "Eine Datei als Text vorschauen; zu große und binäre Dateien nennen stattdessen den Grund.",
+      description: "Preview a file as text; files that are too large or binary state the reason instead.",
       rights: ["runs.read", "runs.inspect"],
       input: Type.Object(browseTarget, { additionalProperties: false }),
       result: openJson<BrowsePreview>("BrowsePreview"),
@@ -182,7 +182,7 @@ export const workspaceContracts = {
   channels: {
     browse: defineChannel({
       id: "ragents.workspace.browse",
-      description: "Meldet jede Änderung unterhalb der beobachteten Wurzel eines Runs.",
+      description: "Reports every change below the observed root of a run.",
       rights: ["runs.read", "runs.inspect"],
       params: Type.Object({ runId: browseTarget.runId, root: browseTarget.root }, { additionalProperties: false }),
       message: Type.Object({ changed: Type.Literal(true) }, { additionalProperties: false }),
@@ -191,28 +191,28 @@ export const workspaceContracts = {
   clients: {
     list: defineOperation({
       id: "ragents.workspace.clients.list",
-      description: "Die angemeldeten Arbeitsplätze des Aufrufers; fremde erscheinen auch mit runs.read.all nicht.",
+      description: "The caller's signed-in workstations; other users' workstations do not appear even with runs.read.all.",
       rights: ["runs.read"],
       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.",
+      description: "The plugins' contributions to the executor that a workstation loads before sign-in and reports back with it. A workstation with a different executor version fails on its version; other fields do not matter.",
       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. Ein Arbeitsplatz mit anderem Executor-Stand scheitert an seinem Stand, bevor die übrige Form zählt.",
+      description: "Sign in a workstation or renew its folders; the connection of this request becomes its return path and needs an event stream. A workstation with a different executor version fails on its version before the rest of the shape matters.",
       rights: ["runs.write"],
       input: Type.Union([clientRegistrationSchema, otherExecutorRegistration]),
       result: clientInfoSchema,
     }),
     unregister: defineOperation({
       id: "ragents.workspace.clients.unregister",
-      description: "Einen eigenen Arbeitsplatz abmelden; offene Aufträge scheitern.",
+      description: "Sign out one of your own workstations; open tasks fail.",
       rights: ["runs.write"],
       input: Type.Object({ id: clientId }, { additionalProperties: false }),
       result: Type.Null(),
@@ -235,7 +235,7 @@ const isFolder = (value: unknown): value is WorkspaceFolder => {
   return hasExactly(value, ["path"]) || (hasExactly(value, ["path", "fresh"]) && value.fresh === true);
 };
 
-/** Einen neuen Ordner mit Pfad gibt es nur auf einem Arbeitsplatz; auf dem Server legt ihn der Host selbst an. */
+/** A new folder with a path exists only on a workstation; on the server the host creates it itself. */
 export const isWorkspaceBinding = (value: unknown): value is WorkspaceBinding =>
   isRecord(value) && hasExactly(value, ["machine", "folder"]) && isMachine(value.machine) && isFolder(value.folder)
   && !(value.machine === "server" && typeof value.folder === "object" && "fresh" in value.folder);
@@ -243,7 +243,7 @@ export const isWorkspaceBinding = (value: unknown): value is WorkspaceBinding =>
 export const isFreshFolder = (folder: WorkspaceFolder): folder is "fresh" | FreshWorkstationFolder =>
   folder === "fresh" || "fresh" in folder;
 
-/** Die Form vor der Trennung von Rechner und Ordner, `{ kind: "fresh" | "path" | "client" }`, eindeutig in der heutigen. */
+/** The shape before machine and folder were separated, `{ kind: "fresh" | "path" | "client" }`, mapped unambiguously to the current one. */
 const fromKind = (value: Record<string, unknown>): unknown => {
   switch (value.kind) {
     case "fresh": return hasExactly(value, ["kind"]) ? freshServerBinding() : undefined;
@@ -255,16 +255,16 @@ const fromKind = (value: Record<string, unknown>): unknown => {
   }
 };
 
-/** Die gespeicherte Bindung; ältere, unveränderliche Journale tragen die Form mit `kind`, und nur hier wird sie abgebildet. */
+/** The stored binding; older, immutable journals carry the shape with `kind`, and only here is it mapped. */
 export const storedWorkspaceBinding = (value: unknown): WorkspaceBinding | undefined => {
   if (isWorkspaceBinding(value)) return value;
   const mapped = isRecord(value) && Object.hasOwn(value, "kind") ? fromKind(value) : undefined;
   return isWorkspaceBinding(mapped) ? mapped : undefined;
 };
 
-export const FRESH_WORKSPACE_LABEL = "Leerer Ordner je Run";
+export const FRESH_WORKSPACE_LABEL = "Empty folder per run";
 
-/** Wie der neue Ordner je Run auf dem Rechner der Bindung heißt; ohne Beitrag dort der leere Ordner. */
+/** What the new folder per run is called on the binding's machine; without a contribution there, the empty folder. */
 const freshLabelOf = (binding: WorkspaceBinding, labels: FreshWorkspaceLabels): string =>
   (binding.machine === "server" ? labels.server : labels.client) ?? FRESH_WORKSPACE_LABEL;
 

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

@@ -36,7 +36,7 @@ const folderSchema = Type.Union([
 
 const bindingSchema = Type.Object({ machine: machineSchema, folder: folderSchema }, { additionalProperties: false });
 
-/** Ein Run auf einem Arbeitsplatz mit dessen Kennung, Label und dem Ordner dort; `fresh` trägt dann schon seinen Pfad. */
+/** A run on a workstation with its ID, label, and the folder there; `fresh` then already carries its path. */
 export type WorkstationBinding = {
   machine: { client: string; label: string };
   folder: ExistingWorkspaceFolder | FreshWorkstationFolder;
@@ -48,20 +48,20 @@ const insideFolder = (folder: string, candidate: string): boolean => {
   return candidate === root || candidate.startsWith(root + separator);
 };
 
-/** Der Ordner eines Runs unter dem Ordner, in dem ein Arbeitsplatz die neuen Ordner je Run anlegt; mit dessen Trennzeichen. */
+/** The folder of a run below the folder in which a workstation creates the new folders per run; with its separator. */
 export const workstationRunFolder = (runsDirectory: string, runId: string): string => {
   const separator = runsDirectory.includes("\\") ? "\\" : "/";
   const root = runsDirectory.endsWith(separator) ? runsDirectory.slice(0, -separator.length) : runsDirectory;
   return `${root}${separator}${runId}`;
 };
 
-/** Die Bindung eines Runs; ohne gespeicherte Wahl der neue Ordner auf dem Server, eine unlesbare sperrt den Run mit Ursache. */
+/** The binding of a run; without a stored choice the new folder on the server, an unreadable one blocks the run with a cause. */
 export const bindingOf = (state: RunState | null): WorkspaceBinding => {
   const stored = storedStartOption(state, WORKSPACE_BINDING_OPTION_ID);
   if (stored === undefined) return freshServerBinding();
   const binding = storedWorkspaceBinding(stored);
   if (!binding || (binding.machine !== "server" && binding.folder === "fresh")) {
-    throw new Error(`Die gespeicherte Arbeitsbereich-Bindung ist ungültig: ${JSON.stringify(stored)}`);
+    throw new Error(`The stored workspace binding is invalid: ${JSON.stringify(stored)}`);
   }
   return binding;
 };
@@ -69,26 +69,26 @@ export const bindingOf = (state: RunState | null): WorkspaceBinding => {
 export const isWorkstationBinding = (binding: WorkspaceBinding): binding is WorkstationBinding =>
   binding.machine !== "server" && binding.folder !== "fresh";
 
-/** Ein Run benutzt nur Arbeitsplätze seines Eigentümers, ein Run ohne Eigentümer nur ohne Benutzer angemeldete. */
+/** A run uses only workstations of its owner, a run without an owner only those signed in without a user. */
 export const workspaceOwnerOf = (state: RunState | null): string | null => state?.ownerUserId ?? null;
 
-/** Der vorhandene Ordner auf dem Serverrechner, an den der Run gebunden ist; ein neuer Ordner und ein Arbeitsplatz liegen nicht dort. */
+/** The existing folder on the server machine that the run is bound to; a new folder and a workstation are not there. */
 export const boundServerDirectory = (state: RunState | null): string | null => {
   const { machine, folder } = bindingOf(state);
   return machine === "server" && folder !== "fresh" ? folder.path : null;
 };
 
-/** Ein vorhandener Ordner dieses Servers; dieselbe Prüfung wie beim Wählen der Startoption. */
+/** An existing folder of this server; the same check as when choosing the start option. */
 export const serverDirectoryFolder = (directory: string): ExistingWorkspaceFolder => {
-  if (!path.isAbsolute(directory)) throw new DomainError("workspace-path-relative", "Der Ordner muss ein absoluter Pfad sein.", 400);
+  if (!path.isAbsolute(directory)) throw new DomainError("workspace-path-relative", "The folder must be an absolute path.", 400);
   const resolved = path.resolve(directory);
   if (!statSync(resolved, { throwIfNoEntry: false })?.isDirectory()) {
-    throw new DomainError("workspace-path-missing", `Der Ordner ${resolved} existiert auf dem Server nicht.`, 400);
+    throw new DomainError("workspace-path-missing", `The folder ${resolved} does not exist on the server.`, 400);
   }
   return { path: resolved };
 };
 
-/** Die Bash eines Runs läuft auf dem Executor seiner Bindung; der Prompt nennt deshalb dessen Plattform und Werkzeuge, nicht die des Servers. */
+/** The bash of a run runs on the executor of its binding; the prompt therefore names its platform and tools, not those of the server. */
 export const executorShellChapter = (
   registry: WorkspaceClientRegistry,
   owner: string | null,
@@ -104,11 +104,11 @@ export const executorShellChapter = (
       + "so the platform of its shell is unknown; the workspace tools fail until it connects again.";
 };
 
-/** Wo die Wurzel eines Runs liegt, in Worten: bei einem Arbeitsplatz mit dessen Label, sonst der Pfad selbst. */
+/** Where the root of a run is, in words: on a workstation with its label, otherwise the path itself. */
 export const workspaceLocation = (binding: WorkspaceBinding, location: string): string =>
-  binding.machine === "server" ? location : `Arbeitsplatz ${binding.machine.label}: ${location}`;
+  binding.machine === "server" ? location : `Workstation ${binding.machine.label}: ${location}`;
 
-/** Den neuen Ordner je Run stellt der Beitrag, sobald es einen gibt; auf einem Arbeitsplatz nur, wenn er es dort ausdrücklich kann. */
+/** The contribution provides the new folder per run as soon as there is one; on a workstation only if it explicitly can there. */
 export const freshLabels = (contribution: WorkspaceResolver | undefined): FreshWorkspaceLabels => ({
   server: contribution?.kind?.label ?? FRESH_WORKSPACE_LABEL,
   client: contribution ? contribution.workstation?.label ?? null : FRESH_WORKSPACE_LABEL,
@@ -121,7 +121,7 @@ export const sessionMetadataOf = (state: RunState | null, contribution: Workspac
 
 const unsupported = (message: string): DomainError => new DomainError("workspace-binding-unsupported", message, 400);
 
-/** Ein Arbeitsplatz des Handelnden, der den Ordner anbietet; ein neuer Ordner je Run bekommt dort seinen Pfad unter dessen Ordner für Runs. */
+/** A workstation of the acting user that offers the folder; a new folder per run gets its path there below its folder for runs. */
 const workstationBinding = (
   client: WorkspaceClientInfo,
   folder: WorkspaceBinding["folder"],
@@ -131,12 +131,12 @@ const workstationBinding = (
   const machine = { client: client.id, label: client.label };
   if (isFreshFolder(folder)) {
     if (labels.client === null) {
-      throw unsupported(`Einen neuen Ordner je Run gibt es hier nur auf dem Server (${labels.server}); wähle dort einen oder einen vorhandenen Ordner des Arbeitsplatzes.`);
+      throw unsupported(`A new folder per run exists here only on the server (${labels.server}); choose one there or an existing folder of the workstation.`);
     }
     return { machine, folder: { path: workstationRunFolder(client.runsDirectory, runId), fresh: true } };
   }
   if (!client.folders.some((offered) => insideFolder(offered, folder.path))) {
-    throw new DomainError("workspace-client-folder", `Der Arbeitsplatz ${client.label} bietet den Ordner ${folder.path} nicht an.`, 400);
+    throw new DomainError("workspace-client-folder", `The workstation ${client.label} does not offer the folder ${folder.path}.`, 400);
   }
   return { machine, folder: { path: folder.path } };
 };
@@ -150,19 +150,19 @@ export const workspaceBindingOption = (
   selectable: () => true,
   defaultValue: () => freshServerBinding(),
   accept: (value, { runId, userId }) => {
-    if (!isWorkspaceBinding(value)) throw new DomainError("workspace-binding-invalid", "Die Arbeitsbereich-Bindung hat kein gültiges Format.", 400);
+    if (!isWorkspaceBinding(value)) throw new DomainError("workspace-binding-invalid", "The workspace binding has no valid format.", 400);
     const labels = freshLabels(contribution());
     const { machine, folder } = value;
     if (machine === "server") {
       if (folder === "fresh") return freshServerBinding();
-      if ("fresh" in folder) throw new DomainError("workspace-binding-invalid", "Einen neuen Ordner je Run legt auf dem Server der Host an; er hat keinen gewählten Pfad.", 400);
+      if ("fresh" in folder) throw new DomainError("workspace-binding-invalid", "On the server, the host creates the new folder per run; it has no chosen path.", 400);
       if (!(contribution()?.kind?.serverFolders ?? true)) {
-        throw unsupported(`Ein vorhandener Ordner auf dem Serverrechner ist hier keine Bindung; wähle ${labels.server} oder einen Arbeitsplatz.`);
+        throw unsupported(`An existing folder on the server machine is not a binding here; choose ${labels.server} or a workstation.`);
       }
       return { machine, folder: serverDirectoryFolder(folder.path) };
     }
     const client = registry.info(userId, machine.client);
-    if (!client) throw new DomainError("workspace-client-disconnected", `Der Arbeitsplatz ${machine.label || machine.client} ist nicht verbunden.`, 409);
+    if (!client) throw new DomainError("workspace-client-disconnected", `The workstation ${machine.label || machine.client} is not connected.`, 409);
     return workstationBinding(client, folder, runId, labels);
   },
   describe: (_value, { userId }) => {

package/plugins/ragents.workspace/server/browse-route.ts

@@ -24,13 +24,13 @@ import {
 
 export interface BrowseOptions {
   ensureSession: (runId: string) => void;
-  /** Der Arbeitsbereich eines Runs, den nur sein Eigentümer bedient, liegt bei ihm; die Dateiablage des Servers nicht. */
+  /** The workspace of a run that only its owner operates is with the owner; the server's file store is not. */
   ensureWorkspaceAccess: (access: AccessContext, runId: string) => void;
-  /** Der Arbeitsbereich ist nur über den Executor des Runs erreichbar, wo immer er liegt. */
+  /** The workspace is reachable only through the run's executor, wherever it is. */
   execute: SandboxServices["execute"];
-  /** Die Dateiablage liegt auf dem Server und gehört nicht zum Arbeitsbereich. */
+  /** The file store is on the server and does not belong to the workspace. */
   documentsFor: (runId: string) => Promise<string>;
-  /** Wie die Wurzel eines Runs heißt, etwa mit dem Label seines Arbeitsplatzes. */
+  /** What the root of a run is called, for example with the label of its workstation. */
   locationOf: (runId: string, location: string) => string;
 }
 
@@ -74,10 +74,10 @@ export const createBrowseMethods = (options: BrowseOptions): MethodContribution[
   }),
 ];
 
-/** Nach dem Ende einer laufenden Beobachtung, etwa weil der Arbeitsplatz weg war, versucht der Kanal es in diesem Abstand erneut. */
+/** After a running watch ends, for example because the workstation was gone, the channel retries at this interval. */
 const WATCH_RETRY_MS = 5_000;
 
-/** Beobachtet den Arbeitsbereich beim Executor des Runs bis zum Abbruch; steht die Beobachtung, ist der Kanal offen, und endet sie, beginnt er eine neue. */
+/** Watches the workspace at the run's executor until aborted; once the watch is established the channel is open, and when it ends, it starts a new one. */
 const watchWorkspace = (options: BrowseOptions, runId: string, changed: () => void): Promise<() => void> =>
   new Promise((ready, failed) => {
     const controller = new AbortController();
@@ -92,10 +92,10 @@ const watchWorkspace = (options: BrowseOptions, runId: string, changed: () => vo
       const ended = (error?: unknown): void => {
         if (controller.signal.aborted) return;
         if (!opened) {
-          failed(error ?? new Error("Die Beobachtung des Arbeitsbereichs endete, bevor sie stand"));
+          failed(error ?? new Error("The workspace watch ended before it was established"));
           return;
         }
-        // Endet eine laufende Beobachtung, lädt die Ansicht neu und zeigt die Ursache; steht die nächste, lädt sie noch einmal.
+        // When a running watch ends, the view reloads and shows the cause; once the next one is established, it reloads again.
         if (watching) changed();
         retry = setTimeout(start, WATCH_RETRY_MS);
       };