@schlenkr/ragents 0.1.10 → 0.1.11

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

@@ -30,24 +30,24 @@ interface ClientEntry {
   readonly owner: string | null;
   readonly connection: MethodConnection;
   readonly release: () => void;
-  /** Die offenen Aufrufe über diese Anmeldung; löst eine neue Verbindung sie ab, scheitern sie sofort. */
+  /** The open calls through this sign-in; if a new connection replaces it, they fail immediately. */
   readonly calls: Set<AbortController>;
-  /** Die Stopps, die gerade über diese Anmeldung zugestellt werden, je Run. */
+  /** The stops currently being delivered through this sign-in, per run. */
   readonly stops: Map<string, Promise<void>>;
 }
 
-/** Die einzige Grenze gegen einen hängenden Arbeitsplatz; seine eigenen Zeitgrenzen hat der Executor. */
+/** The only limit against a hanging workstation; the executor has its own timeouts. */
 const CLIENT_TIMEOUT_MS = 15 * 60 * 1000;
 
-/** So lange wartet Aufräumen (Stopp, `whenReachable`) auf den Arbeitsplatz; es bleibt unter der Stoppgrenze der Plugins. */
+/** This is how long cleanup (stop, `whenReachable`) waits for the workstation; it stays below the plugins' stop limit. */
 const CLEANUP_TIMEOUT_MS = 10_000;
 
-/** Nach so langer Zeit versucht der Server einen ausstehenden Stopp erneut, solange der Arbeitsplatz angemeldet ist. */
+/** After this long, the server retries a pending stop as long as the workstation is signed in. */
 const STOP_RETRY_MS = 30_000;
 
 export const ownerOf = (access: AccessContext): string | null => access.user?.id ?? null;
 
-/** Eine Beobachtung läuft bis zum Abbruch, Aufräumen kurz; alles andere wartet die Sicherheitsgrenze plus der Dauer, die der Aufruf selbst verlangt. */
+/** A watch runs until aborted, cleanup briefly; everything else waits for the safety limit plus the duration the call itself requests. */
 const timeoutFor = (options: WorkspaceExecuteOptions): { timeoutMs?: number } => {
   if (options.untilAborted) return {};
   if (options.whenReachable) return { timeoutMs: CLEANUP_TIMEOUT_MS };
@@ -55,14 +55,14 @@ const timeoutFor = (options: WorkspaceExecuteOptions): { timeoutMs?: number } =>
 };
 
 const disconnected = (label: string, detail: string): DomainError =>
-  new DomainError("workspace-client-disconnected", `Der Arbeitsplatz ${label} hat die Verbindung verloren: ${detail}`, 409);
+  new DomainError("workspace-client-disconnected", `The workstation ${label} lost the connection: ${detail}`, 409);
 
-/** Bricht die Verbindung mitten im Aufruf, muss die Ursache den Arbeitsplatz nennen, nicht den Server; ein fachlicher Fehler bleibt einer. */
+/** If the connection breaks in the middle of a call, the cause must name the workstation, not the server; a domain error stays one. */
 const withClientCause = (cause: unknown, label: string): unknown => {
   if (!(cause instanceof RpcError)) return cause;
   if (cause.code === RPC_ERROR_CODES.connectionClosed) return disconnected(label, cause.message);
   if (cause.code === RPC_ERROR_CODES.timeout) {
-    return new DomainError("workspace-client-timeout", `Der Arbeitsplatz ${label} hat nicht geantwortet: ${cause.message}`, 504);
+    return new DomainError("workspace-client-timeout", `The workstation ${label} did not respond: ${cause.message}`, 504);
   }
   if (cause.code === RPC_ERROR_CODES.application && cause.domainCode !== undefined && cause.status !== undefined) {
     return new DomainError(cause.domainCode, cause.message, cause.status);
@@ -70,61 +70,61 @@ const withClientCause = (cause: unknown, label: string): unknown => {
   return cause;
 };
 
-/** Der Arbeitsplatz war nicht da oder hat nicht rechtzeitig geantwortet; ein fachlicher Fehler zählt nicht dazu. */
+/** The workstation was not there or did not respond in time; a domain error does not count. */
 const unreached = (cause: unknown): boolean =>
   cause instanceof DomainError && (cause.code === "workspace-client-disconnected" || cause.code === "workspace-client-timeout");
 
 const messageOf = (cause: unknown): string => cause instanceof Error ? cause.message : String(cause);
 
-/** Ein Arbeitsplatz ist erst durch Besitzer und Kennung bestimmt; zwei Benutzer mit derselben Kennung teilen nichts. */
+/** A workstation is identified only by owner and ID; two users with the same ID share nothing. */
 const keyOf = (owner: string | null, id: string): string => JSON.stringify([owner, id]);
 
-/** Server und Arbeitsplatz brauchen denselben Executor; die Meldung sagt, wer von beiden zu alt ist. */
+/** Server and workstation need the same executor; the message says which of the two is too old. */
 const assertExecutor = (label: string, executor: string): void => {
   if (executor === WORKSPACE_EXECUTOR_VERSION) return;
   const action = Number(executor) > Number(WORKSPACE_EXECUTOR_VERSION)
-    ? "Den Server auf die Fassung des Arbeitsplatzes aktualisieren."
-    : "Die RAgents-Erweiterung in VS Code beziehungsweise das Paket @schlenkr/ragents auf dem Arbeitsplatz aktualisieren.";
+    ? "Update the server to the workstation's version."
+    : "Update the RAgents extension in VS Code or the package @schlenkr/ragents on the workstation.";
   throw new DomainError(
     "workspace-executor-version",
-    `Der Arbeitsplatz ${label} bringt den Executor ${executor} mit, der Server verlangt ${WORKSPACE_EXECUTOR_VERSION}. ${action}`,
+    `The workstation ${label} brings executor ${executor}, the server requires ${WORKSPACE_EXECUTOR_VERSION}. ${action}`,
     409,
   );
 };
 
 const described = (contributions: readonly ExecutorContributionStand[]): string =>
-  contributions.map(({ plugin, stand }) => `${plugin} (${stand.slice(0, 12)})`).join(", ") || "keine";
+  contributions.map(({ plugin, stand }) => `${plugin} (${stand.slice(0, 12)})`).join(", ") || "none";
 
-/** Ein Arbeitsplatz führt aus, was die Plugins des Servers beitragen; mit anderen Beiträgen liefen dieselben Werkzeuge dort anders als auf dem Server. */
+/** A workstation runs what the server's plugins contribute; with other contributions the same tools would behave differently there than on the server. */
 const assertContributions = (label: string, expected: readonly ExecutorContributionStand[], given: readonly ExecutorContributionStand[]): void => {
   const key = (entry: ExecutorContributionStand): string => `${entry.plugin}\0${entry.stand}`;
   const same = expected.length === given.length && expected.every((entry) => given.some((other) => key(other) === key(entry)));
   if (same) return;
   throw new DomainError(
     "workspace-executor-contributions",
-    `Der Arbeitsplatz ${label} bringt die Executor-Beiträge ${described(given)} mit, der Server verlangt ${described(expected)}. `
-      + "Der Arbeitsplatz fragt sie mit ragents.workspace.clients.contributions ab und meldet sich danach erneut an.",
+    `The workstation ${label} brings the executor contributions ${described(given)}, the server requires ${described(expected)}. `
+      + "The workstation queries them with ragents.workspace.clients.contributions and then signs in again.",
     409,
   );
 };
 
-/** Über das Netz nimmt der Server Arbeitsplätze nur von angemeldeten Benutzern an; ohne Benutzer gäbe es nur einen Besitzer für alle Zugänge. */
+/** Over the network, the server accepts workstations only from signed-in users; without users there would be only one owner for all access. */
 export const assertMayRegister = (access: AccessContext, local: boolean): void => {
   if (local || (access.enabled && access.user !== null)) return;
   throw new DomainError(
     "workspace-client-login-required",
-    "Dieser Server kennt keine Benutzeranmeldung; einen Arbeitsplatz nimmt er deshalb nur über eine Loopback-Verbindung an "
-      + "(etwa http://127.0.0.1 auf seinem eigenen Rechner). Über das Netz braucht ein Arbeitsplatz ein Profil mit Benutzern.",
+    "This server has no user sign-in; it therefore accepts a workstation only over a loopback connection "
+      + "(such as http://127.0.0.1 on its own machine). Over the network, a workstation needs a profile with users.",
     403,
   );
 };
 
-/** Kennt die angemeldeten Arbeitsplätze je Besitzer, hält je Client die Verbindung, über die der Server ihn zurückruft, und die Stopps, die ihn nicht erreicht haben. */
+/** Knows the signed-in workstations per owner, holds per client the connection through which the server calls it back, and the stops that have not reached it. */
 export class WorkspaceClientRegistry {
-  /** Was die Plugins des Servers zum Executor beitragen; jeder Arbeitsplatz muss genau diese Beiträge tragen. */
+  /** What the server's plugins contribute to the executor; every workstation must carry exactly these contributions. */
   readonly contributions: readonly ExecutorContributionStand[];
   readonly #clients = new Map<string, ClientEntry>();
-  /** Stopps, die den Arbeitsplatz noch nicht erreicht haben, je Arbeitsplatz und Run mit dem Ordner der Bindung. */
+  /** Stops that have not reached the workstation yet, per workstation and run with the folder of the binding. */
   readonly #pendingStops = new Map<string, Map<string, string>>();
   readonly #stopRetries = new Map<string, NodeJS.Timeout>();
 
@@ -140,7 +140,7 @@ export class WorkspaceClientRegistry {
     connection: MethodConnection,
   ): Promise<WorkspaceClientInfo> {
     if (connection.streamless) {
-      throw new DomainError("stream-required", "Die Anmeldung eines Arbeitsplatzes braucht einen Ereignisstrom.", 409);
+      throw new DomainError("stream-required", "The sign-in of a workstation needs an event stream.", 409);
     }
     assertExecutor(description.label, executor);
     assertContributions(description.label, this.contributions, contributions);
@@ -164,7 +164,7 @@ export class WorkspaceClientRegistry {
     return info;
   }
 
-  /** Nur die Verbindung, die den Eintrag hält, meldet ihn ab; eine Abmeldung ohne Eintrag ist nach einer Trennung kein Fehler. */
+  /** Only the connection that holds the entry signs it out; a sign-out without an entry is not an error after a disconnect. */
   unregister(owner: string | null, id: string, connection: MethodConnection): void {
     const key = keyOf(owner, id);
     const entry = this.#clients.get(key);
@@ -180,25 +180,25 @@ export class WorkspaceClientRegistry {
     return this.#clients.get(keyOf(owner, id))?.info;
   }
 
-  /** Die Runs, deren Stopp diesen Arbeitsplatz noch nicht erreicht hat. */
+  /** The runs whose stop has not reached this workstation yet. */
   pendingStops(owner: string | null, id: string): readonly string[] {
     return this.#pendingRuns(keyOf(owner, id));
   }
 
-  /** Der Executor eines gebundenen Runs: dieselbe Schnittstelle wie im Server, nur über die Verbindung des Arbeitsplatzes seines Besitzers. */
+  /** The executor of a bound run: the same interface as in the server, only through the connection of its owner's workstation. */
   executorFor(owner: string | null, id: string, label: string, cwd: string): WorkspaceExecutor {
     const key = keyOf(owner, id);
     const call = async (runId: string, operation: string, input: unknown, options: WorkspaceExecuteOptions): Promise<unknown> => {
-      if (options.untilAborted && !options.signal) throw new Error(`Die Operation ${operation} läuft bis zum Abbruch und braucht dafür ein Abbruchsignal`);
+      if (options.untilAborted && !options.signal) throw new Error(`The operation ${operation} runs until aborted and needs an abort signal for that`);
       if (this.#pendingStops.get(key)?.has(runId)) {
-        // Aufräumen neben einem ausstehenden Stopp erledigt dieser mit; alles andere wartet, bis er zugestellt ist.
+        // Cleanup alongside a pending stop is done by that stop; everything else waits until it is delivered.
         if (options.whenReachable) return null;
         if (this.#clients.has(key)) await this.#deliverStop(key, runId);
       }
       const entry = this.#clients.get(key);
       if (!entry) {
         if (options.whenReachable) return null;
-        throw new DomainError("workspace-client-disconnected", `Der Arbeitsplatz ${label} ist nicht verbunden.`, 409);
+        throw new DomainError("workspace-client-disconnected", `The workstation ${label} is not connected.`, 409);
       }
       try {
         return await this.#send(entry, runId, operation, input, cwd, options);
@@ -229,7 +229,7 @@ export class WorkspaceClientRegistry {
     this.#pendingStops.clear();
   }
 
-  /** Ein getrennter Arbeitsplatz verlässt die Registry; eine spätere Anmeldung über eine neue Verbindung bleibt stehen. */
+  /** A disconnected workstation leaves the registry; a later sign-in over a new connection stays. */
   #disconnected(key: string, connection: MethodConnection): void {
     const entry = this.#clients.get(key);
     if (entry?.connection !== connection) return;
@@ -242,7 +242,7 @@ export class WorkspaceClientRegistry {
     this.#abandon(entry);
   }
 
-  /** Eine Verbindung, die niemand mehr hält, bekommt keine Antworten mehr zugestellt; ihre offenen Aufrufe scheitern sofort. */
+  /** A connection that nobody holds anymore gets no more answers delivered; its open calls fail immediately. */
   #abandon(entry: ClientEntry): void {
     for (const controller of entry.calls) controller.abort();
     entry.calls.clear();
@@ -279,7 +279,7 @@ export class WorkspaceClientRegistry {
           },
         ),
         new Promise<never>((_settle, fail) => abandoned.signal.addEventListener("abort", () =>
-          fail(disconnected(label, "eine neue Verbindung hat die Anmeldung abgelöst")), { once: true })),
+          fail(disconnected(label, "a new connection replaced the sign-in")), { once: true })),
       ]);
       return value;
     } catch (cause) {
@@ -297,13 +297,13 @@ export class WorkspaceClientRegistry {
     return created;
   }
 
-  /** Stellt einen ausstehenden Stopp zu; erreicht er den Arbeitsplatz nicht, bleibt er ausstehend, und die nächste Anmeldung holt ihn nach. */
+  /** Delivers a pending stop; if it does not reach the workstation, it stays pending and the next sign-in catches up on it. */
   #deliverStop(key: string, runId: string): Promise<void> {
     const entry = this.#clients.get(key);
     const cwd = this.#pendingStops.get(key)?.get(runId);
     if (cwd === undefined) return Promise.resolve();
     if (!entry) {
-      console.warn(`Der Stopp des Runs ${runId} erreicht seinen Arbeitsplatz erst bei dessen nächster Anmeldung.`);
+      console.warn(`The stop of run ${runId} reaches its workstation only at its next sign-in.`);
       return Promise.resolve();
     }
     const running = entry.stops.get(runId);
@@ -314,7 +314,7 @@ export class WorkspaceClientRegistry {
           this.#stopDelivered(key, runId, cwd);
           throw cause;
         }
-        console.warn(`Der Stopp des Runs ${runId} hat den Arbeitsplatz ${entry.info.label} nicht erreicht und bleibt ausstehend: ${messageOf(cause)}`);
+        console.warn(`The stop of run ${runId} did not reach the workstation ${entry.info.label} and stays pending: ${messageOf(cause)}`);
         this.#retryStops(key);
       })
       .finally(() => entry.stops.delete(runId));
@@ -331,7 +331,7 @@ export class WorkspaceClientRegistry {
   #deliverPendingStops(key: string): void {
     for (const runId of this.#pendingRuns(key)) {
       void this.#deliverStop(key, runId).catch((cause: unknown) =>
-        console.warn(`Der nachgeholte Stopp des Runs ${runId} ist gescheitert: ${messageOf(cause)}`));
+        console.warn(`The delayed stop of run ${runId} failed: ${messageOf(cause)}`));
     }
   }
 
@@ -339,7 +339,7 @@ export class WorkspaceClientRegistry {
     return [...this.#pendingStops.get(key)?.keys() ?? []];
   }
 
-  /** Ein Arbeitsplatz, der angemeldet bleibt, aber nicht antwortet, bekommt seine ausstehenden Stopps später noch einmal. */
+  /** A workstation that stays signed in but does not respond gets its pending stops again later. */
   #retryStops(key: string): void {
     if (this.#stopRetries.has(key)) return;
     const timer = setTimeout(() => {
@@ -360,11 +360,11 @@ export const clientMethods = (registry: WorkspaceClientRegistry): MethodContribu
   }),
   implement(workspaceContracts.clients.register, (input, { access, connection, local }) => {
     assertMayRegister(access, local);
-    // Erst der Stand: ein Arbeitsplatz mit einem anderen kennt die Form dieses Stands nicht, mit diesem gilt sie ganz.
+    // Version first: a workstation with a different one does not know the shape of this version; with this one, the shape applies fully.
     assertExecutor(input.label, input.executor);
     if (!Value.Check(clientRegistrationSchema, input)) {
       throw new RpcError(RPC_ERROR_CODES.invalidParams,
-        `Ungültige Eingabe für ${workspaceContracts.clients.register.id}: ${schemaComplaints(clientRegistrationSchema, input, "params")}`);
+        `Invalid input for ${workspaceContracts.clients.register.id}: ${schemaComplaints(clientRegistrationSchema, input, "params")}`);
     }
     const { id, executor, contributions, ...description } = input;
     return registry.register(id, description, executor, contributions, connection);

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

@@ -16,14 +16,14 @@ export interface ProcessSandboxSetting {
   readonly network: readonly string[];
 }
 
-/** So schaltet der Betreiber die Prozess-Sandbox in der Profildatei ab. */
-export const PROCESS_SANDBOX_OFF = 'PROCESS_SANDBOX: "off" in der Sektion ragents.workspace';
+/** This is how the operator turns off the process sandbox in the profile file. */
+export const PROCESS_SANDBOX_OFF = 'PROCESS_SANDBOX: "off" in the ragents.workspace section';
 
-/** Ohne Angabe ist die Sandbox an; abschalten geht nur ausdrücklich mit "off". */
+/** Without a value the sandbox is on; it can only be turned off explicitly with "off". */
 export const processSandboxSetting = (): ProcessSandboxSetting => {
   const mode = env.optional("PROCESS_SANDBOX") ?? "on";
   if (mode !== "on" && mode !== "off") {
-    throw new Error(`PROCESS_SANDBOX in der Sektion ragents.workspace ist "on" oder "off", nicht "${mode}"`);
+    throw new Error(`PROCESS_SANDBOX in the ragents.workspace section is "on" or "off", not "${mode}"`);
   }
   const network = env.optional("PROCESS_SANDBOX_NETWORK") === undefined
     ? PROCESS_SANDBOX_DEFAULT_NETWORK
@@ -31,12 +31,12 @@ export const processSandboxSetting = (): ProcessSandboxSetting => {
   return { enabled: mode === "on", network };
 };
 
-/** Die Bash, mit der der Executor dieses Servers das Werkzeug bash startet; unter Windows setzt sie die VS-Code-Erweiterung für ihren lokalen Host. */
+/** The bash with which the executor of this server starts the bash tool; on Windows the VS Code extension sets it for its local host. */
 export const bashSetting = (): string | undefined => env.optional("RAGENTS_BASH") || undefined;
 
-/** Das rg, das der Executor dieses Servers vorn in den PATH der Bash setzt; die VS-Code-Erweiterung setzt es für ihren lokalen Host. */
+/** The rg that the executor of this server puts at the front of the bash PATH; the VS Code extension sets it for its local host. */
 export const rgSetting = (): string | undefined => env.optional("RAGENTS_RG") || undefined;
 
-/** Die Zeitgrenze von bash in Sekunden für Aufrufe ohne eigene; mehr als die größte, die ein Aufruf nennen darf, lehnt das Werkzeug beim Start ab. */
+/** The bash timeout in seconds for calls without their own; the tool rejects more than the largest a call may name at startup. */
 export const bashTimeoutSetting = (): number | undefined =>
   env.optional("RAGENTS_BASH_TIMEOUT_SECONDS") ? env.positiveNumber("RAGENTS_BASH_TIMEOUT_SECONDS", "") : undefined;

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

@@ -27,7 +27,7 @@ import { bashSetting, bashTimeoutSetting, PROCESS_SANDBOX_OFF, processSandboxSet
 import { RunWorkspaceRuntime } from "./runtime.js";
 
 const warnWithoutSandbox = (): void => {
-  console.warn(`Prozess-Sandbox ausgeschaltet (${PROCESS_SANDBOX_OFF}): Prozesse der Runs laufen auf dem Server ohne Sandbox.`);
+  console.warn(`Process sandbox turned off (${PROCESS_SANDBOX_OFF}): run processes run on the server without a sandbox.`);
 };
 
 const ragentsWorkspacePlugin = (skillPaths: () => Promise<readonly string[]>): RAgentsPlugin => ({
@@ -47,7 +47,7 @@ const ragentsWorkspacePlugin = (skillPaths: () => Promise<readonly string[]>): R
       host.optionalService(documentStoreToken)?.directoryFor(runId) ?? Promise.resolve(undefined);
     const documentsRoot = async (runId: string): Promise<string> => {
       const directory = await documentsFor(runId);
-      if (!directory) throw new Error("In diesem Profil gibt es keine Dateiablage; das Plugin ragents.documents fehlt");
+      if (!directory) throw new Error("This profile has no file store; the plugin ragents.documents is missing");
       return directory;
     };
     const contributions = host.service(executorContributionsToken);
@@ -99,7 +99,7 @@ const ragentsWorkspacePlugin = (skillPaths: () => Promise<readonly string[]>): R
       boundToTools({
         ...rules,
         delivery: "initial",
-        // Die Regeln gelten für die Arbeitsbereiche des Hosts; eine beigesteuerte Art beschreibt ihre eigenen.
+        // The rules apply to the host's workspaces; a contributed kind describes its own.
         render: (context) => contribution()?.kind ? "" : rules.render(context),
       }, ...agentWorkspaceToolNames),
       shellPlatformPrompt("ragents.workspace.shell.prompt", 102, serverTools, (runId) => {

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

@@ -38,7 +38,7 @@ import type { WorkspaceClientRegistry } from "./clients.js";
 export interface RunWorkspaceRuntimeOptions {
   globalDirectory: string;
   sessionDirectory: (runId: string, ...segments: string[]) => string;
-  /** Die Speichergrenze eines Runs; innerhalb davon gehören private Arbeitsdateien seinem Konto. */
+  /** The storage boundary of a run; within it, private work files belong to its account. */
   storageRootFor: (runId: string) => string;
   sessionsDirectoryPattern: string;
   sessionWorkspaceFor: (runId: string) => Promise<SessionWorkspace>;
@@ -47,21 +47,21 @@ export interface RunWorkspaceRuntimeOptions {
   runState: (runId: string) => RunState | null;
   storeBinding: (runId: string, binding: WorkspaceBinding) => void;
   clients: WorkspaceClientRegistry;
-  /** Was die Plugins des Profils zum Executor des Servers beitragen; die Arbeitsplätze laden dieselben Beiträge selbst. */
+  /** What the profile's plugins contribute to the server's executor; the workstations load the same contributions themselves. */
   contributions: readonly WorkspaceExecutorParts[];
-  /** Die Prozess-Sandbox des Servers; ohne sie laufen die Prozesse des Servers ohne. */
+  /** The server's process sandbox; without it, the server's processes run without one. */
   processSandbox?: RunProcessSandboxes;
-  /** Die Bash des Servers aus RAGENTS_BASH; unter Windows Pflicht für das Werkzeug bash. */
+  /** The server's bash from RAGENTS_BASH; required on Windows for the bash tool. */
   bash?: string;
-  /** Das rg des Servers aus RAGENTS_RG; ohne Angabe gilt eines im PATH. */
+  /** The server's rg from RAGENTS_RG; without a value, one in the PATH applies. */
   rg?: string;
-  /** Die Zeitgrenze von bash aus RAGENTS_BASH_TIMEOUT_SECONDS; ohne Angabe die des Werkzeugs. */
+  /** The bash timeout from RAGENTS_BASH_TIMEOUT_SECONDS; without a value, that of the tool. */
   bashTimeoutSeconds?: number;
 }
 
 const runNotStarted = (): DomainError => new DomainError(
   "run-not-started",
-  "Der Run ist noch nicht gestartet; das Arbeitsverzeichnis entsteht mit der ersten Nachricht.",
+  "The run has not started yet; the working directory is created with the first message.",
   409,
 );
 
@@ -109,7 +109,7 @@ const variableList = (roots: readonly ServerRootDescription[]): string => listed
 
 const hasVariables = (roots: readonly ServerRootDescription[]): boolean => roots.some((root) => root.environmentVariable !== undefined);
 
-/** Auf dem Server liegen Arbeitsbereich und Wurzeln auf einer Maschine; jede Bash sieht beide. */
+/** On the server, workspace and roots are on one machine; every bash sees both. */
 const serverRootsDescription = (roots: readonly ServerRootDescription[]): string => [
   "## Roots besides the working directory",
   "",
@@ -118,7 +118,7 @@ const serverRootsDescription = (roots: readonly ServerRootDescription[]): string
     + (hasVariables(roots) ? ` \`bash\` also has ${variableList(roots)}.` : ""),
 ].join("\n");
 
-/** Die Wurzeln liegen auf dem Server, der Arbeitsbereich auf dem Arbeitsplatz; eine Bash sieht immer nur eine der beiden Maschinen. */
+/** The roots are on the server, the workspace on the workstation; a bash always sees only one of the two machines. */
 const workstationRootsDescription = (roots: readonly ServerRootDescription[]): string => [
   "## Roots on the server",
   "",
@@ -135,7 +135,7 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
   readonly transfer: WorkspaceTransfer;
   readonly #options: RunWorkspaceRuntimeOptions;
   readonly #nugetCacheDirectory: string;
-  /** Die neuen Ordner auf Arbeitsplätzen, die in diesem Serverlauf schon angelegt oder in Arbeit sind. */
+  /** The new folders on workstations that have already been created or are in progress during this server run. */
   readonly #preparations = new Map<string, Promise<void>>();
 
   constructor(options: RunWorkspaceRuntimeOptions) {
@@ -163,7 +163,7 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     });
   }
 
-  /** Arbeit eines Runs, die auf dem Server läuft, während sein Arbeitsbereich auf einem Arbeitsplatz liegt. */
+  /** Work of a run that runs on the server while its workspace is on a workstation. */
   async #serverDirectoryFor(runId: string): Promise<string> {
     const directory = this.#options.sessionDirectory(runId, "server");
     await mkdir(directory, { recursive: true });
@@ -177,7 +177,7 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     return { home, nugetPackages: this.#nugetCacheDirectory };
   }
 
-  /** Auf einem Arbeitsplatz führt dessen Executor im Namen des Run-Eigentümers aus, sonst der des Servers. */
+  /** On a workstation, its executor runs on behalf of the run owner, otherwise the server's executor. */
   #executorFor(runId: string): WorkspaceExecutor | undefined {
     const state = this.#options.runState(runId);
     const binding = bindingOf(state);
@@ -187,7 +187,7 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     return "fresh" in folder ? this.#preparing(state, binding, executor) : executor;
   }
 
-  /** Vor dem ersten Auftrag eines Runs legt der Arbeitsplatz dessen neuen Ordner an; Aufräumen legt nie einen an. */
+  /** Before the first task of a run, the workstation creates its new folder; cleanup never creates one. */
   #preparing(state: RunState | null, binding: WorkstationBinding, executor: WorkspaceExecutor): WorkspaceExecutor {
     return {
       ...executor,
@@ -209,7 +209,7 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     return preparation;
   }
 
-  /** Nur ein eben angelegter Ordner bekommt die Schritte des Beitrags; scheitert einer, verschwindet er wieder, und der nächste Auftrag beginnt neu. */
+  /** Only a freshly created folder gets the contribution's steps; if one fails, the folder disappears again and the next task starts over. */
   async #prepare(runId: string, state: RunState | null, binding: WorkstationBinding, executor: WorkspaceExecutor): Promise<void> {
     const { created } = await executor.execute(runId, RUN_FOLDER_OPERATIONS.create, null) as RunFolderCreated;
     const steps = created ? this.#contribution()?.workstation?.prepare(this.#workstationContext(runId, state, binding)) ?? [] : [];
@@ -246,7 +246,7 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     return this.#withRoots(workspace, onWorkstation);
   }
 
-  /** Was der Prompt über Wurzeln sagt, hängt an der Maschine des Runs: nur eine Bash auf dem Server kennt ihre Variablen. */
+  /** What the prompt says about roots depends on the run's machine: only a bash on the server knows their variables. */
   async #withRoots(workspace: SessionWorkspace, onWorkstation: boolean): Promise<SessionWorkspace> {
     const roots = await this.sandbox.serverRoots();
     if (roots.length === 0) return workspace;
@@ -293,10 +293,10 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
       try {
         return await realpath(cwd);
       } catch {
-        throw new DomainError("workspace-path-missing", `Der gebundene Ordner ${cwd} existiert auf dem Server nicht mehr.`, 409);
+        throw new DomainError("workspace-path-missing", `The bound folder ${cwd} no longer exists on the server.`, 409);
       }
     };
-    emitSystem(`Arbeitsbereich: ${cwd} (Projektordner auf dem Server)`);
+    emitSystem(`Workspace: ${cwd} (project folder on the server)`);
     return {
       cwd,
       description: serverProjectDescription(cwd),
@@ -305,17 +305,17 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     };
   }
 
-  /** Der Arbeitsbereich liegt auf dem Arbeitsplatz; der Server kennt nur seinen Pfad, und jeder lokale Griff darauf scheitert laut. */
+  /** The workspace is on the workstation; the server knows only its path, and every local access to it fails loudly. */
   #workstation(runId: string, state: RunState, binding: WorkstationBinding, emitSystem: (text: string) => void): SessionWorkspace {
     const { machine: { label }, folder } = binding;
     const fresh = "fresh" in folder;
     const workstation = this.#contribution()?.workstation;
     emitSystem(fresh
-      ? `Arbeitsbereich: ${folder.path} (${workstation?.label ?? FRESH_WORKSPACE_LABEL} auf dem Arbeitsplatz ${label})`
-      : `Arbeitsbereich: ${folder.path} (Projektordner auf dem Arbeitsplatz ${label})`);
+      ? `Workspace: ${folder.path} (${workstation?.label ?? FRESH_WORKSPACE_LABEL} on the workstation ${label})`
+      : `Workspace: ${folder.path} (project folder on the workstation ${label})`);
     const remote = (): Promise<string> => Promise.reject(new Error(
-      `Der Arbeitsbereich ${folder.path} liegt auf dem Arbeitsplatz ${label}, nicht auf dem Server; `
-      + "er ist nur über den Executor des Runs (SandboxServices.execute) erreichbar.",
+      `The workspace ${folder.path} is on the workstation ${label}, not on the server; `
+      + "it is reachable only through the run's executor (SandboxServices.execute).",
     ));
     const description = !fresh
       ? clientProjectDescription(folder.path, label)
@@ -348,7 +348,7 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     if (resolver.optionId === undefined) return null;
     const choice = storedStartOption(state, resolver.optionId);
     if (choice === undefined) {
-      throw new Error(`Die Startoption ${resolver.optionId} des Workspace-Resolvers ist im Run nicht gespeichert`);
+      throw new Error(`The start option ${resolver.optionId} of the workspace resolver is not stored in the run`);
     }
     return choice;
   }
@@ -365,13 +365,13 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     return this.#options.resolver();
   }
 
-  /** Auf dem Server gehört ein neuer Ordner samt Stopp und Löschen dem Beitrag; auf einem Arbeitsplatz räumt ihn der Host weg. */
+  /** On the server, a new folder including stop and deletion belongs to the contribution; on a workstation, the host cleans it up. */
   #serverContributionFor(runId: string): WorkspaceResolver | undefined {
     const { machine, folder } = bindingOf(this.#options.runState(runId));
     return machine === "server" && isFreshFolder(folder) ? this.#contribution() : undefined;
   }
 
-  /** Ist der Arbeitsplatz nicht erreichbar, bleibt der Ordner dort mit Hinweis liegen; der Run ist trotzdem gelöscht. */
+  /** If the workstation is unreachable, the folder stays there with a notice; the run is deleted anyway. */
   async #removeWorkstationFolder(runId: string): Promise<void> {
     this.#preparations.delete(runId);
     const state = this.#options.runState(runId);
@@ -382,7 +382,7 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     const steps = this.#contribution()?.workstation?.release?.(this.#workstationContext(runId, state, binding)) ?? [];
     await this.#runSteps(runId, executor, steps, { whenReachable: true });
     if (await executor.execute(runId, RUN_FOLDER_OPERATIONS.remove, null, { whenReachable: true }) !== null) return;
-    console.warn(`Der Ordner ${folder.path} des Runs ${runId} bleibt auf dem Arbeitsplatz ${machine.label}, weil er nicht erreichbar war.`);
+    console.warn(`The folder ${folder.path} of run ${runId} stays on the workstation ${machine.label} because it was unreachable.`);
   }
 
   async deleteSession(runId: string): Promise<void> {

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

@@ -5,7 +5,7 @@ import { boundToTools } from "@ragents/host/plugin-support/prompt.js";
 export const shellPlatformChapter = (platform: NodeJS.Platform, tools: ShellTools): string =>
   `## Shell platform\n\n${shellPlatformText(platform, tools)}`;
 
-/** Ohne Angabe gelten Plattform und Werkzeuge des Servers; `chapterFor` nennt die des Executors, der den Run ausführt. */
+/** Without a value, the platform and tools of the server apply; `chapterFor` names those of the executor that runs the run. */
 export const shellPlatformPrompt = (
   id: string,
   order: number,

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

@@ -22,13 +22,13 @@ const previewSourceClass = "min-w-0 px-2.5 pt-0 pb-2.5 text-xs leading-[1.45] wh
 const indent = (depth: number) => ({ "--row-indent": `${8 + depth * 12}px` }) as CSSProperties;
 
 const rootLabels: Readonly<Record<BrowseRoot, string>> = {
-  workspace: "Arbeitsverzeichnis",
-  files: "Dateiablage",
+  workspace: "Working directory",
+  files: "File storage",
 };
 
 const emptyHints: Readonly<Record<BrowseRoot, string>> = {
-  workspace: "Im Arbeitsverzeichnis des Runs liegt noch nichts.",
-  files: "In der Dateiablage des Runs liegt noch nichts.",
+  workspace: "There is nothing in the run's working directory yet.",
+  files: "There is nothing in the run's file storage yet.",
 };
 
 const messageOf = (cause: unknown): string => cause instanceof Error ? cause.message : String(cause);
@@ -41,7 +41,7 @@ const sizeLabel = (bytes: number): string => {
 
 const timeLabel = (value: string): string => {
   const at = new Date(value);
-  return Number.isNaN(at.getTime()) ? value : at.toLocaleString("de-DE");
+  return Number.isNaN(at.getTime()) ? value : at.toLocaleString("en-US");
 };
 
 interface BrowserMemory {
@@ -208,7 +208,7 @@ export function FileBrowserPanel({ active, session }: WorkspaceTabContext) {
         })}
         {listing.truncated && (
           <div className="py-1 pr-2.5 pl-(--row-indent) text-[0.64rem] text-muted-foreground" style={indent(depth)}>
-            Weitere Einträge sind nicht gelistet.
+            Further entries are not listed.
           </div>
         )}
       </>
@@ -229,15 +229,15 @@ export function FileBrowserPanel({ active, session }: WorkspaceTabContext) {
         </div>
         <div className="flex items-center gap-1">
           <Toggle
-            aria-label={showHidden ? "Versteckte Einträge ausblenden" : "Versteckte Einträge anzeigen"}
+            aria-label={showHidden ? "Hide hidden entries" : "Show hidden entries"}
             onPressedChange={setShowHidden}
             pressed={showHidden}
             size="sm"
-            title={showHidden ? "Versteckte Einträge ausblenden" : "Versteckte Einträge anzeigen"}
+            title={showHidden ? "Hide hidden entries" : "Show hidden entries"}
           >
             {showHidden ? <Eye size={15} strokeWidth={1.8} /> : <EyeOff size={15} strokeWidth={1.8} />}
           </Toggle>
-          <Button aria-label="Dateien aktualisieren" onClick={() => setReload((value) => value + 1)} size="icon" title="Aktualisieren" variant="ghost">
+          <Button aria-label="Refresh files" onClick={() => setReload((value) => value + 1)} size="icon" title="Refresh" variant="ghost">
             <RefreshCw className={pending ? "animate-spin" : undefined} size={15} strokeWidth={1.8} />
           </Button>
         </div>
@@ -252,7 +252,7 @@ export function FileBrowserPanel({ active, session }: WorkspaceTabContext) {
         <Empty className="min-h-30 flex-none gap-2 p-7">
           <EmptyHeader>
             <EmptyMedia><FolderOpen size={15} strokeWidth={1.7} /></EmptyMedia>
-            <EmptyTitle>Keine Dateien</EmptyTitle>
+            <EmptyTitle>No files</EmptyTitle>
             <EmptyDescription>{emptyHints[root]}</EmptyDescription>
           </EmptyHeader>
         </Empty>