@schlenkr/ragents 0.1.10 → 0.1.12

package/bundles/ragents.workspace/server/index.js

@@ -60,20 +60,20 @@ var WORKSPACE_BINDING_OPTION_ID = "ragents.workspace.binding";
 var WORKSPACE_METADATA_ID = "ragents.workspace";
 var freshServerBinding = () => ({ machine: "server", folder: "fresh" });
 var WORKSPACE_CLIENT_ID_PATTERN = /^[A-Za-z0-9_-]{8,64}$/;
-var clientId = Type.String({ pattern: "^[A-Za-z0-9_-]{8,64}$", description: "Stabile Kennung des Arbeitsplatzes" });
-var executorVersion = Type.String({ minLength: 1, maxLength: 64, description: "Stand des Executors, den der Arbeitsplatz mitbringt" });
+var clientId = Type.String({ pattern: "^[A-Za-z0-9_-]{8,64}$", description: "Stable ID of the workstation" });
+var executorVersion = Type.String({ minLength: 1, maxLength: 64, description: "Version of the executor that the workstation brings" });
 var PLUGIN_ID_PATTERN = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
 var 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\xE4ge 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" }),
+  revision: 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" });
 var 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" })
 };
 var clientInfoSchema = Type.Object({
   id: Type.String(),
@@ -86,43 +86,43 @@ var clientRegistrationSchema = Type.Object({
   contributions: executorContributions
 }, { additionalProperties: false });
 var 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"
 });
-var absolutePath = Type.String({ minLength: 1, description: "Absoluter Pfad im gebundenen Ordner" });
+var absolutePath = Type.String({ minLength: 1, description: "Absolute path in the bound folder" });
 var WORKSPACE_CLIENT_STOP_OPERATION = "stop";
 var workspaceClientContracts = {
   execute: defineOperation({
     id: "ragents.workspace.client.execute",
-    description: "Eine Operation des Executors auf dem Arbeitsplatz ausf\xFChren, etwa ein Werkzeug, eine Dateiabfrage oder die Prozessanzeige; das Ergebnis ist ihr Wert, Fortschritt ihr JSON-Wert. stop gibt frei, was der Arbeitsplatz f\xFCr den Run h\xE4lt.",
+    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\xE4gt: 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 })
   })
 };
 var 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" })
 };
 var 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")
     }),
     preview: defineOperation({
       id: "ragents.workspace.browse.preview",
-      description: "Eine Datei als Text vorschauen; zu gro\xDFe und bin\xE4re 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")
@@ -131,7 +131,7 @@ var workspaceContracts = {
   channels: {
     browse: defineChannel({
       id: "ragents.workspace.browse",
-      description: "Meldet jede \xC4nderung 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 })
@@ -140,28 +140,28 @@ var workspaceContracts = {
   clients: {
     list: defineOperation({
       id: "ragents.workspace.clients.list",
-      description: "Die angemeldeten Arbeitspl\xE4tze 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\xE4ge der Plugins zum Executor, die ein Arbeitsplatz vor der Anmeldung l\xE4dt und mit ihr zur\xFCckmeldet. Ein Arbeitsplatz mit anderem Executor-Stand scheitert an seinem Stand; weitere Felder z\xE4hlen 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\xFCckweg und braucht einen Ereignisstrom. Ein Arbeitsplatz mit anderem Executor-Stand scheitert an seinem Stand, bevor die \xFCbrige Form z\xE4hlt.",
+      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\xE4ge 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()
@@ -195,7 +195,7 @@ var storedWorkspaceBinding = (value) => {
   const mapped = isRecord(value) && Object.hasOwn(value, "kind") ? fromKind(value) : void 0;
   return isWorkspaceBinding(mapped) ? mapped : void 0;
 };
-var FRESH_WORKSPACE_LABEL = "Leerer Ordner je Run";
+var FRESH_WORKSPACE_LABEL = "Empty folder per run";
 var freshLabelOf = (binding, labels) => (binding.machine === "server" ? labels.server : labels.client) ?? FRESH_WORKSPACE_LABEL;
 var workspaceBindingSummary = (binding, labels) => {
   const { machine, folder } = binding;
@@ -234,7 +234,7 @@ var bindingOf = (state) => {
   if (stored === void 0) return freshServerBinding();
   const binding = storedWorkspaceBinding(stored);
   if (!binding || binding.machine !== "server" && binding.folder === "fresh") {
-    throw new Error(`Die gespeicherte Arbeitsbereich-Bindung ist ung\xFCltig: ${JSON.stringify(stored)}`);
+    throw new Error(`The stored workspace binding is invalid: ${JSON.stringify(stored)}`);
   }
   return binding;
 };
@@ -245,10 +245,10 @@ var boundServerDirectory = (state) => {
   return machine === "server" && folder !== "fresh" ? folder.path : null;
 };
 var serverDirectoryFolder = (directory) => {
-  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 };
 };
@@ -260,7 +260,7 @@ var executorShellChapter = (registry, owner, binding, serverTools) => {
 
 The workstation ${machine.label} that holds this project is not registered right now, so the platform of its shell is unknown; the workspace tools fail until it connects again.`;
 };
-var workspaceLocation = (binding, location) => binding.machine === "server" ? location : `Arbeitsplatz ${binding.machine.label}: ${location}`;
+var workspaceLocation = (binding, location) => binding.machine === "server" ? location : `Workstation ${binding.machine.label}: ${location}`;
 var freshLabels = (contribution) => ({
   server: contribution?.kind?.label ?? FRESH_WORKSPACE_LABEL,
   client: contribution ? contribution.workstation?.label ?? null : FRESH_WORKSPACE_LABEL
@@ -274,12 +274,12 @@ var workstationBinding = (client, folder, runId, labels) => {
   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\xE4hle 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 } };
 };
@@ -289,19 +289,19 @@ var workspaceBindingOption = (registry, contribution) => ({
   selectable: () => true,
   defaultValue: () => freshServerBinding(),
   accept: (value, { runId, userId }) => {
-    if (!isWorkspaceBinding(value)) throw new DomainError("workspace-binding-invalid", "Die Arbeitsbereich-Bindung hat kein g\xFCltiges 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\xE4hlten 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\xE4hle ${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 }) => {
@@ -378,7 +378,7 @@ var watchWorkspace = (options, runId, changed) => new Promise((ready, failed) =>
     const ended = (error) => {
       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;
       }
       if (watching) changed();
@@ -431,12 +431,12 @@ var timeoutFor = (options) => {
   if (options.whenReachable) return { timeoutMs: CLEANUP_TIMEOUT_MS };
   return { timeoutMs: CLIENT_TIMEOUT_MS + (options.durationMs ?? 0) };
 };
-var disconnected = (label, detail) => new DomainError2("workspace-client-disconnected", `Der Arbeitsplatz ${label} hat die Verbindung verloren: ${detail}`, 409);
+var disconnected = (label, detail) => new DomainError2("workspace-client-disconnected", `The workstation ${label} lost the connection: ${detail}`, 409);
 var withClientCause = (cause, label) => {
   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 DomainError2("workspace-client-timeout", `Der Arbeitsplatz ${label} hat nicht geantwortet: ${cause.message}`, 504);
+    return new DomainError2("workspace-client-timeout", `The workstation ${label} did not respond: ${cause.message}`, 504);
   }
   if (cause.code === RPC_ERROR_CODES.application && cause.domainCode !== void 0 && cause.status !== void 0) {
     return new DomainError2(cause.domainCode, cause.message, cause.status);
@@ -448,21 +448,21 @@ var messageOf = (cause) => cause instanceof Error ? cause.message : String(cause
 var keyOf = (owner, id) => JSON.stringify([owner, id]);
 var assertExecutor = (label, executor) => {
   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.";
+  const action = Number(executor) > Number(WORKSPACE_EXECUTOR_VERSION) ? "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 DomainError2(
     "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
   );
 };
-var described = (contributions) => contributions.map(({ plugin: plugin2, stand }) => `${plugin2} (${stand.slice(0, 12)})`).join(", ") || "keine";
+var described = (contributions) => contributions.map(({ plugin: plugin2, revision }) => `${plugin2} (${revision.slice(0, 12)})`).join(", ") || "none";
 var assertContributions = (label, expected, given) => {
-  const key = (entry) => `${entry.plugin}\0${entry.stand}`;
+  const key = (entry) => `${entry.plugin}\0${entry.revision}`;
   const same = expected.length === given.length && expected.every((entry) => given.some((other) => key(other) === key(entry)));
   if (same) return;
   throw new DomainError2(
     "workspace-executor-contributions",
-    `Der Arbeitsplatz ${label} bringt die Executor-Beitr\xE4ge ${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
   );
 };
@@ -470,23 +470,23 @@ var assertMayRegister = (access, local) => {
   if (local || access.enabled && access.user !== null) return;
   throw new DomainError2(
     "workspace-client-login-required",
-    "Dieser Server kennt keine Benutzeranmeldung; einen Arbeitsplatz nimmt er deshalb nur \xFCber eine Loopback-Verbindung an (etwa http://127.0.0.1 auf seinem eigenen Rechner). \xDCber 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
   );
 };
 var WorkspaceClientRegistry = class {
-  /** 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. */
   contributions;
   #clients = /* @__PURE__ */ new Map();
-  /** 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. */
   #pendingStops = /* @__PURE__ */ new Map();
   #stopRetries = /* @__PURE__ */ new Map();
   constructor(contributions) {
-    this.contributions = contributions.map(({ plugin: plugin2, stand }) => ({ plugin: plugin2, stand }));
+    this.contributions = contributions.map(({ plugin: plugin2, revision }) => ({ plugin: plugin2, revision }));
   }
   async register(id, description, executor, contributions, connection) {
     if (connection.streamless) {
-      throw new DomainError2("stream-required", "Die Anmeldung eines Arbeitsplatzes braucht einen Ereignisstrom.", 409);
+      throw new DomainError2("stream-required", "The sign-in of a workstation needs an event stream.", 409);
     }
     assertExecutor(description.label, executor);
     assertContributions(description.label, this.contributions, contributions);
@@ -509,7 +509,7 @@ var WorkspaceClientRegistry = class {
     this.#deliverPendingStops(key);
     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, id, connection) {
     const key = keyOf(owner, id);
     const entry = this.#clients.get(key);
@@ -522,15 +522,15 @@ var WorkspaceClientRegistry = class {
   info(owner, id) {
     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, id) {
     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, id, label, cwd) {
     const key = keyOf(owner, id);
     const call = async (runId, operation, input, options) => {
-      if (options.untilAborted && !options.signal) throw new Error(`Die Operation ${operation} l\xE4uft bis zum Abbruch und braucht daf\xFCr 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)) {
         if (options.whenReachable) return null;
         if (this.#clients.has(key)) await this.#deliverStop(key, runId);
@@ -538,7 +538,7 @@ var WorkspaceClientRegistry = class {
       const entry = this.#clients.get(key);
       if (!entry) {
         if (options.whenReachable) return null;
-        throw new DomainError2("workspace-client-disconnected", `Der Arbeitsplatz ${label} ist nicht verbunden.`, 409);
+        throw new DomainError2("workspace-client-disconnected", `The workstation ${label} is not connected.`, 409);
       }
       try {
         return await this.#send(entry, runId, operation, input, cwd, options);
@@ -567,7 +567,7 @@ var WorkspaceClientRegistry = class {
     this.#stopRetries.clear();
     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, connection) {
     const entry = this.#clients.get(key);
     if (entry?.connection !== connection) return;
@@ -578,7 +578,7 @@ var WorkspaceClientRegistry = class {
     this.#clients.delete(key);
     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) {
     for (const controller of entry.calls) controller.abort();
     entry.calls.clear();
@@ -606,7 +606,7 @@ var WorkspaceClientRegistry = class {
             ...options.onProgress ? { onProgress: options.onProgress } : {}
           }
         ),
-        new Promise((_settle, fail) => abandoned.signal.addEventListener("abort", () => fail(disconnected(label, "eine neue Verbindung hat die Anmeldung abgel\xF6st")), { once: true }))
+        new Promise((_settle, fail) => abandoned.signal.addEventListener("abort", () => fail(disconnected(label, "a new connection replaced the sign-in")), { once: true }))
       ]);
       return value;
     } catch (cause) {
@@ -622,13 +622,13 @@ var WorkspaceClientRegistry = class {
     this.#pendingStops.set(key, created);
     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, runId) {
     const entry = this.#clients.get(key);
     const cwd = this.#pendingStops.get(key)?.get(runId);
     if (cwd === void 0) return Promise.resolve();
     if (!entry) {
-      console.warn(`Der Stopp des Runs ${runId} erreicht seinen Arbeitsplatz erst bei dessen n\xE4chster 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);
@@ -638,7 +638,7 @@ var WorkspaceClientRegistry = class {
         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));
     entry.stops.set(runId, delivery);
@@ -651,13 +651,13 @@ var WorkspaceClientRegistry = class {
   }
   #deliverPendingStops(key) {
     for (const runId of this.#pendingRuns(key)) {
-      void this.#deliverStop(key, runId).catch((cause) => console.warn(`Der nachgeholte Stopp des Runs ${runId} ist gescheitert: ${messageOf(cause)}`));
+      void this.#deliverStop(key, runId).catch((cause) => console.warn(`The delayed stop of run ${runId} failed: ${messageOf(cause)}`));
     }
   }
   #pendingRuns(key) {
     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) {
     if (this.#stopRetries.has(key)) return;
     const timer = setTimeout(() => {
@@ -681,7 +681,7 @@ var clientMethods = (registry) => [
     if (!Value.Check(clientRegistrationSchema, input)) {
       throw new RpcError(
         RPC_ERROR_CODES.invalidParams,
-        `Ung\xFCltige Eingabe f\xFCr ${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;
@@ -704,11 +704,11 @@ var workspaceConfigDescriptors = [
   { key: "RAGENTS_BASH_TIMEOUT_SECONDS", source: "environment" }
 ];
 var env = declaredEnvironment(workspaceConfigDescriptors);
-var PROCESS_SANDBOX_OFF = 'PROCESS_SANDBOX: "off" in der Sektion ragents.workspace';
+var PROCESS_SANDBOX_OFF = 'PROCESS_SANDBOX: "off" in the ragents.workspace section';
 var 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") === void 0 ? PROCESS_SANDBOX_DEFAULT_NETWORK : env.list("PROCESS_SANDBOX_NETWORK");
   return { enabled: mode === "on", network };
@@ -728,7 +728,7 @@ import { storedStartOption as storedStartOption2 } from "@ragents/host/ragents/s
 import { WorkspaceSandboxHost } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
 var runNotStarted = () => new DomainError3(
   "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
 );
 var lookAround = "Look around in it before you say anything about the project.";
@@ -779,7 +779,7 @@ var RunWorkspaceRuntime = class {
   transfer;
   #options;
   #nugetCacheDirectory;
-  /** 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. */
   #preparations = /* @__PURE__ */ new Map();
   constructor(options) {
     this.#options = options;
@@ -805,7 +805,7 @@ var RunWorkspaceRuntime = class {
       ...options.bashTimeoutSeconds === void 0 ? {} : { bashTimeoutSeconds: options.bashTimeoutSeconds }
     });
   }
-  /** 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) {
     const directory = this.#options.sessionDirectory(runId, "server");
     await mkdir(directory, { recursive: true });
@@ -817,7 +817,7 @@ var RunWorkspaceRuntime = class {
     await mkdir(this.#nugetCacheDirectory, { recursive: true });
     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) {
     const state = this.#options.runState(runId);
     const binding = bindingOf(state);
@@ -826,7 +826,7 @@ var RunWorkspaceRuntime = class {
     const executor = this.#options.clients.executorFor(workspaceOwnerOf(state), machine.client, machine.label, folder.path);
     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, binding, executor) {
     return {
       ...executor,
@@ -846,7 +846,7 @@ var RunWorkspaceRuntime = class {
     this.#preparations.set(runId, preparation);
     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, state, binding, executor) {
     const { created } = await executor.execute(runId, RUN_FOLDER_OPERATIONS.create, null);
     const steps = created ? this.#contribution()?.workstation?.prepare(this.#workstationContext(runId, state, binding)) ?? [] : [];
@@ -878,7 +878,7 @@ var RunWorkspaceRuntime = class {
     const workspace = onWorkstation ? this.#workstation(runId, state, binding, emitSystem) : isFreshFolder(folder) ? await this.#fresh(runId, state, emitSystem) : this.#bound(folder, emitSystem);
     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, onWorkstation) {
     const roots = await this.sandbox.serverRoots();
     if (roots.length === 0) return workspace;
@@ -920,10 +920,10 @@ var RunWorkspaceRuntime = class {
       try {
         return await realpath(cwd);
       } catch {
-        throw new DomainError3("workspace-path-missing", `Der gebundene Ordner ${cwd} existiert auf dem Server nicht mehr.`, 409);
+        throw new DomainError3("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),
@@ -931,14 +931,14 @@ var RunWorkspaceRuntime = class {
       runOperation: (operation) => operation()
     };
   }
-  /** 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, state, binding, emitSystem) {
     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})`);
+    emitSystem(fresh ? `Workspace: ${folder.path} (${workstation?.label ?? FRESH_WORKSPACE_LABEL} on the workstation ${label})` : `Workspace: ${folder.path} (project folder on the workstation ${label})`);
     const remote = () => Promise.reject(new Error(
-      `Der Arbeitsbereich ${folder.path} liegt auf dem Arbeitsplatz ${label}, nicht auf dem Server; er ist nur \xFCber 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) : workstation?.description?.(this.#workstationContext(runId, state, binding)) ?? freshWorkstationDescription(folder.path, label);
     return {
@@ -966,7 +966,7 @@ var RunWorkspaceRuntime = class {
     if (resolver.optionId === void 0) return null;
     const choice = storedStartOption2(state, resolver.optionId);
     if (choice === void 0) {
-      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;
   }
@@ -979,12 +979,12 @@ var RunWorkspaceRuntime = class {
   #contribution() {
     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) {
     const { machine, folder } = bindingOf(this.#options.runState(runId));
     return machine === "server" && isFreshFolder(folder) ? this.#contribution() : void 0;
   }
-  /** 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) {
     this.#preparations.delete(runId);
     const state = this.#options.runState(runId);
@@ -995,7 +995,7 @@ var RunWorkspaceRuntime = class {
     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) {
     const contribution = this.#serverContributionFor(runId);
@@ -1016,7 +1016,7 @@ var RunWorkspaceRuntime = class {
 
 // server/index.ts
 var warnWithoutSandbox = () => {
-  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.`);
 };
 var ragentsWorkspacePlugin = (skillPaths) => ({
   manifest: { id: "ragents.workspace" },
@@ -1034,7 +1034,7 @@ var ragentsWorkspacePlugin = (skillPaths) => ({
     const documentsFor = (runId) => host.optionalService(documentStoreToken)?.directoryFor(runId) ?? Promise.resolve(void 0);
     const documentsRoot = async (runId) => {
       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);
@@ -1084,7 +1084,7 @@ var ragentsWorkspacePlugin = (skillPaths) => ({
       boundToTools2({
         ...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) => {