@schlenkr/ragents 0.1.9 → 0.1.11

package/packages/workspace-executor/src/processes/snapshot.ts

@@ -33,7 +33,7 @@ export const labelOf = (command: string): string => {
 
 export interface ObservationInput {
   runId: string;
-  /** Der Prozess dieses Executors; seine direkten Kinder sind laufende Werkzeugaufrufe. */
+  /** The process of this executor; its direct children are running tool calls. */
   executorPid: number;
   records: readonly ProcessRecord[];
   markerOf: (record: ProcessRecord) => string | undefined;
@@ -49,7 +49,7 @@ const byPort = (left: WorkspaceProcessPort, right: WorkspaceProcessPort): number
 const byAppearance = (left: WorkspaceProcess, right: WorkspaceProcess): number =>
   left.seenSince.localeCompare(right.seenSince) || left.pid - right.pid;
 
-/** Prozesse des Runs: Hintergrundprozesse immer, Kinder eines laufenden Werkzeugaufrufs nur mit offenem Port. */
+/** Processes of the run: background processes always, children of a running tool call only with an open port. */
 export const runProcessesFrom = (input: ObservationInput): WorkspaceProcess[] => {
   const toolCallGroups = new Set(
     input.records.filter((record) => record.ppid === input.executorPid).map((record) => record.pgid),

package/packages/workspace-executor/src/processes/terminator.ts

@@ -4,7 +4,7 @@ import { processIdOf, type ProcessRecord, type ProcessTable } from "./process-ta
 
 export interface ProcessTerminationOptions {
   table: ProcessTable;
-  /** Der Prozess dieses Executors; er und seine Vorfahren sind geschützt. */
+  /** The process of this executor; it and its ancestors are protected. */
   executorPid: number;
   executorUid: number | undefined;
   termGraceMs?: number;
@@ -42,14 +42,14 @@ export class RunProcessTerminator {
     this.#pollIntervalMs = options.pollIntervalMs ?? 100;
     this.#sendSignal = options.sendSignal ?? ((pid, signal) => { process.kill(pid, signal); });
     for (const duration of [this.#termGraceMs, this.#killGraceMs, this.#timeoutMs, this.#pollIntervalMs]) {
-      if (!Number.isSafeInteger(duration) || duration < 1) throw new Error("Prozess-Stopp-Zeitgrenzen müssen positive ganze Zahlen sein");
+      if (!Number.isSafeInteger(duration) || duration < 1) throw new Error("Process stop timeouts must be positive integers");
     }
   }
 
   async stop(runId: string, processId: string, context: ProcessTerminationContext = {}): Promise<void> {
     const pid = Number(processId.split("-")[0]);
     if (!/^[1-9]\d*-[a-f0-9]{64}$/.test(processId) || !Number.isSafeInteger(pid) || pid > 2_147_483_647)
-      throw new WorkspaceOperationError("invalid-process", "Ungültige Prozessreferenz", 400);
+      throw new WorkspaceOperationError("invalid-process", "Invalid process reference", 400);
     await this.#stop(runId, processId, context);
   }
 
@@ -58,13 +58,13 @@ export class RunProcessTerminator {
   }
 
   async #stop(runId: string, processId: string | undefined, context: ProcessTerminationContext): Promise<void> {
-    if (runMarkerOf(runId) !== runId) throw new WorkspaceOperationError("invalid-run", "Ungültige Laufkennung", 400);
+    if (runMarkerOf(runId) !== runId) throw new WorkspaceOperationError("invalid-run", "Invalid run id", 400);
     const deadline = Date.now() + this.#timeoutMs;
     const attempts = new Map<string, Attempt>();
     const failures = new Map<string, unknown>();
     const assertClean = () => {
       if (failures.size === 1) throw [...failures.values()][0];
-      if (failures.size > 1) throw new AggregateError([...failures.values()], `Prozess-Stopp ist für ${failures.size} Prozesse fehlgeschlagen`);
+      if (failures.size > 1) throw new AggregateError([...failures.values()], `Process stop failed for ${failures.size} processes`);
     };
     let first = true;
     let emptyScans = 0;
@@ -76,8 +76,8 @@ export class RunProcessTerminator {
       const markers = await this.#bounded(this.#options.table.runMarkers(readable.map((record) => record.pid)), deadline);
       if (first && processId !== undefined && selected.length > 0) {
         const record = selected[0];
-        if (processIdOf(record) !== processId) throw new WorkspaceOperationError("stale-process", "Die Prozess-ID wurde inzwischen neu vergeben. Bitte die Prozessliste aktualisieren.", 409);
-        if (markers.get(record.pid) !== runId) throw new WorkspaceOperationError("process-run-mismatch", "Der Prozess gehört nicht zu diesem Run", 403);
+        if (processIdOf(record) !== processId) throw new WorkspaceOperationError("stale-process", "The process ID has been reassigned in the meantime. Please refresh the process list.", 409);
+        if (markers.get(record.pid) !== runId) throw new WorkspaceOperationError("process-run-mismatch", "The process does not belong to this run", 403);
       }
       first = false;
       const targets = readable.filter((record) => markers.get(record.pid) === runId
@@ -100,7 +100,7 @@ export class RunProcessTerminator {
             } else if (attempt.killAt === undefined && Date.now() - attempt.termAt >= this.#termGraceMs) {
               if (await this.#signal(record, runId, "SIGKILL", context, deadline)) attempt.killAt = Date.now();
             } else if (attempt.killAt !== undefined && Date.now() - attempt.killAt >= this.#killGraceMs) {
-              throw new Error(`Prozess ${record.pid} von Run ${runId} ist nach SIGKILL noch aktiv`);
+              throw new Error(`Process ${record.pid} of run ${runId} is still active after SIGKILL`);
             }
           } catch (error) {
             this.#assertActive(context, deadline);
@@ -125,19 +125,19 @@ export class RunProcessTerminator {
       protectedPids.add(parent);
       parent = records.find((candidate) => candidate.pid === parent)?.ppid;
     }
-    if (protectedPids.has(record.pid)) throw new WorkspaceOperationError("protected-process", `Prozess ${record.pid} gehört zum geschützten Prozessbaum des Executors`, 403);
+    if (protectedPids.has(record.pid)) throw new WorkspaceOperationError("protected-process", `Process ${record.pid} belongs to the protected process tree of the executor`, 403);
   }
 
   #assertActive(context: ProcessTerminationContext, deadline: number): void {
     context.signal?.throwIfAborted();
-    if (Date.now() >= deadline) throw new Error(`Prozess-Stopp hat die Zeitgrenze von ${this.#timeoutMs} ms überschritten`);
+    if (Date.now() >= deadline) throw new Error(`Process stop exceeded the timeout of ${this.#timeoutMs} ms`);
   }
 
   async #bounded<T>(operation: Promise<T>, deadline: number): Promise<T> {
     let timer: ReturnType<typeof setTimeout> | undefined;
     try {
       return await Promise.race([operation, new Promise<never>((_, reject) => {
-        timer = setTimeout(() => reject(new Error("Die Prozesstabelle antwortet nicht innerhalb der Stopp-Zeitgrenze")), Math.max(1, deadline - Date.now()));
+        timer = setTimeout(() => reject(new Error("The process table does not answer within the stop timeout")), Math.max(1, deadline - Date.now()));
       })]);
     } finally {
       if (timer) clearTimeout(timer);
@@ -149,7 +149,7 @@ export class RunProcessTerminator {
     const records = await this.#bounded(this.#options.table.list(), deadline);
     const current = records.find((record) => record.pid === expected.pid);
     if (!current || current.startKey !== expected.startKey || current.uid !== expected.uid) return false;
-    if (markers.get(current.pid) !== runId) throw new WorkspaceOperationError("process-run-mismatch", `Prozess ${current.pid} gehört nicht mehr zu diesem Run`, 403);
+    if (markers.get(current.pid) !== runId) throw new WorkspaceOperationError("process-run-mismatch", `Process ${current.pid} no longer belongs to this run`, 403);
     this.#assertUnprotected(current, records);
     this.#assertActive(context, deadline);
     try {
@@ -157,7 +157,7 @@ export class RunProcessTerminator {
       return true;
     } catch (error) {
       if (gone(error)) return false;
-      throw new Error(`${signal} für Prozess ${current.pid} ist fehlgeschlagen: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(`${signal} for process ${current.pid} failed: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 }

package/packages/workspace-executor/src/run-folders.ts

@@ -8,15 +8,15 @@ export const RUN_FOLDER_OPERATIONS = {
 } as const;
 
 export interface RunFolderCreated {
-  /** Ob der Ordner eben entstanden ist; ein schon vorhandener bleibt, wie er ist. */
+  /** Whether the folder was just created; an existing one stays as it is. */
   created: boolean;
 }
 
-/** Der neue Ordner je Run auf dieser Maschine; nur ein Executor, der einen Ordner für Runs kennt, legt ihn an, und nur diesen einen je Run. */
+/** The new folder per run on this machine; only an executor that knows a folder for runs creates it, and only this one per run. */
 export const runFolderModule = (folderOf: ((runId: string) => string) | undefined): WorkspaceModuleFactory => () => {
   const folder = (runId: string): string => {
     if (!folderOf) {
-      throw new WorkspaceOperationError("run-folder-unavailable", "Dieser Executor legt keine Ordner je Run an; auf dem Server tut das der Host", 409);
+      throw new WorkspaceOperationError("run-folder-unavailable", "This executor creates no folders per run; on the server the host does that", 409);
     }
     return folderOf(runId);
   };

package/packages/workspace-executor/src/safe-environment.ts

@@ -46,16 +46,16 @@ export const safeProcessEnvironment = (source: NodeJS.ProcessEnv): NodeJS.Proces
   return environment;
 };
 
-/** Die Variablen des umgebenden Editors; ein Kindprozess, der sie erbt, hängt sich an VS Code oder Electron. */
+/** The variables of the surrounding editor; a child process that inherits them attaches itself to VS Code or Electron. */
 const isEditorVariable = (name: string): boolean => name.startsWith("VSCODE_") || name.startsWith("ELECTRON_");
 
-/** Was eine nicht interaktive Bash von sich aus einliest; über sie käme eine Startdatei des Benutzers in jeden Befehl. */
+/** What a non-interactive bash reads in by itself; through it a startup file of the user would get into every command. */
 const BASH_STARTUP_VARIABLES: ReadonlySet<string> = new Set(["BASH_ENV", "ENV"]);
 
-/** Die ganze Umgebung eines Prozesses ohne die Variablen des umgebenden Editors. */
+/** The whole environment of a process without the variables of the surrounding editor. */
 export const editorFreeEnvironment = (source: NodeJS.ProcessEnv): Record<string, string> => Object.fromEntries(Object.entries(source)
   .filter((entry): entry is [string, string] => typeof entry[1] === "string" && !isEditorVariable(entry[0])));
 
-/** Die geerbte Umgebung für Prozesse auf dem eigenen Rechner des Benutzers: alles außer Editor-Variablen und den Startdateien der Bash. */
+/** The inherited environment for processes on the user's own machine: everything except editor variables and the startup files of the bash. */
 export const inheritedProcessEnvironment = (source: NodeJS.ProcessEnv): Record<string, string> => Object.fromEntries(
   Object.entries(editorFreeEnvironment(source)).filter(([name]) => !BASH_STARTUP_VARIABLES.has(name)));

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

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import {
@@ -12,7 +12,7 @@ import {
 import { bashLaunch } from "./bash-launch.js";
 import type { WorkspaceProcessContext } from "./context.js";
 import { WorkspaceOperationError } from "./errors.js";
-import { processGroupExists, stopProcessTree } from "./managed-process.js";
+import { MSYS_CALL_ENV, processGroupExists, stopMsysCall, stopProcessTree } from "./managed-process.js";
 import type { WorkspaceModuleFactory, WorkspaceOperation } from "./module.js";
 import { sandboxedLaunch } from "./process-sandbox.js";
 import { stopUidProcesses } from "./session-ident.js";
@@ -42,15 +42,15 @@ export interface SandboxTools {
 
 type ToolResult = { content?: Array<{ type: string; text?: string }>; details?: unknown };
 
-/** Der Stand einer Datei, den das Modell zuletzt gesehen hat; der Host führt ihn je Actor und gibt ihn mit, das Modell nennt ihn nie. */
+/** The state of a file that the model saw last; the host keeps it per actor and passes it along, the model never names it. */
 export interface SeenFile {
   readonly file: string;
   readonly hash: string;
-  /** Nur nach einem read: der gelesene Ausschnitt. */
+  /** Only after a read: the section that was read. */
   readonly read?: { readonly offset?: number; readonly limit?: number };
 }
 
-/** Die Eingabe der Dateiwerkzeuge: was das Modell übergibt, und nur bei dessen direktem Aufruf der Stand, den es gesehen hat (`null`: keiner). */
+/** The input of the file tools: what the model passes, and only on its direct call the state it has seen (`null`: none). */
 type FileToolInput = {
   readonly path?: unknown;
   readonly offset?: number;
@@ -61,11 +61,11 @@ type FileToolInput = {
 
 type FileToolName = "read" | "edit" | "write";
 
-const unchangedNotice = "Unverändert seit dem letzten read in diesem Gespräch; der frühere Inhalt gilt weiter.";
+const unchangedNotice = "Unchanged since the last read in this conversation; the earlier content still applies.";
 
 const sha256 = (content: Buffer | string): string => createHash("sha256").update(content).digest("hex");
 
-/** Der Inhalts-Hash einer Datei; eine fehlende Datei hat keinen. */
+/** The content hash of a file; a missing file has none. */
 const currentHash = async (file: string): Promise<string | undefined> => {
   try {
     return sha256(await readFile(file));
@@ -77,11 +77,11 @@ const currentHash = async (file: string): Promise<string | undefined> => {
 
 const detailHash = (result: unknown, name: FileToolName): string => {
   const hash = (result as { details?: { contentHash?: unknown } }).details?.contentHash;
-  if (typeof hash !== "string") throw new Error(`Das Werkzeug ${name} meldet keinen Inhalts-Hash`);
+  if (typeof hash !== "string") throw new Error(`The tool ${name} reports no content hash`);
   return hash;
 };
 
-/** Ein Ergebnis und ein Fehler nennen den Pfad so, wie das Modell ihn übergeben hat, nicht den aufgelösten. */
+/** A result and an error name the path as the model passed it, not the resolved one. */
 const withShownPath = (result: unknown, resolved: string, shown: string): unknown => {
   const typed = result as ToolResult;
   if (resolved === shown || !Array.isArray(typed.content)) return result;
@@ -103,7 +103,7 @@ export const withAnnotation = (result: unknown, note: string | undefined): unkno
   return { ...typed, content: [...typed.content, { type: "text", text: note }] };
 };
 
-/** Löst `$RAGENTS_..._DIR` und `${...}` am Anfang eines Pfads gegen die Variablen des Kontexts auf. */
+/** Resolves `$RAGENTS_..._DIR` and `${...}` at the start of a path against the variables of the context. */
 const expandPathVariables = (value: string, variables: Readonly<Record<string, string>>): string => {
   for (const [name, root] of Object.entries(variables)) {
     for (const prefix of [`$${name}`, `\${${name}}`]) {
@@ -125,10 +125,14 @@ export const createSandboxTools = async (
   let toolOperation: Promise<void> = Promise.resolve();
   let shuttingDown = false;
   const processGroups = new Set<number>();
+  const msysCalls = new Map<number, { readonly bash: string; readonly env: NodeJS.ProcessEnv; readonly marker: string }>();
 
   const killProcessGroup = async (pid: number): Promise<void> => {
     if (onWindows) {
       stopProcessTree(pid);
+      const call = msysCalls.get(pid);
+      msysCalls.delete(pid);
+      if (call) await stopMsysCall(call.bash, call.env, call.marker);
       processGroups.delete(pid);
       return;
     }
@@ -149,7 +153,7 @@ export const createSandboxTools = async (
     await killProcessGroup(pid);
     const deadline = Date.now() + 5_000;
     while (await processGroupExists(pid)) {
-      if (Date.now() >= deadline) throw new Error(`Bash-Prozessgruppe ${pid} konnte nicht beendet werden`);
+      if (Date.now() >= deadline) throw new Error(`Bash process group ${pid} could not be ended`);
       await new Promise((resolve) => setTimeout(resolve, 25));
     }
     processGroups.delete(pid);
@@ -172,8 +176,8 @@ export const createSandboxTools = async (
   };
 
   const concurrent = (execute: ToolExecute): ToolExecute => (toolCallId, input, signal, onUpdate) => {
-    if (shuttingDown) throw new Error("Die Werkzeuge werden killed");
-    if (signal?.aborted) throw new Error("Abgebrochen");
+    if (shuttingDown) throw new Error("The tools are being killed");
+    if (signal?.aborted) throw new Error("Cancelled");
     const run = () => execute(toolCallId, input, signal, onUpdate);
     return initial.runOperation ? initial.runOperation(run) : run();
   };
@@ -188,7 +192,7 @@ export const createSandboxTools = async (
     };
   };
 
-  /** Bei einem direkten Aufruf des Modells prüft ein Schreiben den gesehenen Stand und ein erneutes read eines unveränderten Ausschnitts antwortet knapp. */
+  /** On a direct call of the model a write checks the seen state, and a repeated read of an unchanged section answers briefly. */
   const checkedAgainstSeen = async (name: FileToolName, file: string, shown: string, input: FileToolInput, seen: SeenFile | null): Promise<ToolResult | undefined> => {
     if (name === "read") {
       const sameView = seen?.read !== undefined && seen.file === file && seen.read.offset === input.offset && seen.read.limit === input.limit;
@@ -196,10 +200,10 @@ export const createSandboxTools = async (
     }
     const current = await currentHash(file);
     if (current === undefined) return undefined;
-    if (seen === null || seen.file !== file) throw new WorkspaceOperationError("workspace-file-unread", `${shown}: Datei zuerst mit read lesen.`, 409);
+    if (seen === null || seen.file !== file) throw new WorkspaceOperationError("workspace-file-unread", `${shown}: read the file with read first.`, 409);
     if (seen.hash !== current) {
       throw new WorkspaceOperationError("workspace-file-changed",
-        `${shown}: Datei wurde seit dem Lesen geändert (vom Benutzer, einem Formatter oder einem anderen Actor); erneut lesen.`, 409);
+        `${shown}: the file was changed since it was read (by the user, a formatter or another actor); read it again.`, 409);
     }
     return undefined;
   };
@@ -241,44 +245,46 @@ export const createSandboxTools = async (
     return writing ? serial(checked) : concurrent(checked);
   };
 
-  /** Der Ordner eines Bash-Aufrufs: relativ zum Arbeitsverzeichnis oder mit Alias, auf jedem Rechner gleich, darum nie absolut, und immer in einer Wurzel des Runs. */
+  /** The folder of a bash call: relative to the working directory or with an alias, the same on every machine, therefore never absolute, and always in a root of the run. */
   const inFolder = (execute: ToolExecute): ToolExecute => async (toolCallId, input, signal, onUpdate) => {
     const params = input as { cwd?: unknown } | undefined;
     if (params?.cwd === undefined) return execute(toolCallId, input, signal, onUpdate);
     const requested = params.cwd;
     if (typeof requested !== "string" || requested === "" || path.isAbsolute(requested)) {
       throw new WorkspaceOperationError("workspace-path-invalid",
-        `cwd nennt einen Ordner relativ zum Arbeitsverzeichnis oder beginnt mit einem Alias wie @actors; ${JSON.stringify(requested)} ist das nicht`, 400);
+        `cwd names a folder relative to the working directory or starts with an alias like @actors; ${JSON.stringify(requested)} is neither`, 400);
     }
     const context = await contextFor();
     const directory = await allowedWorkspacePath(path.resolve(cwd, expandWorkspaceAlias(requested, context.workspaceAliases ?? {})),
       [context.root, ...context.additionalRoots ?? [], ...context.readOnlyRoots ?? []]);
     if (!(await stat(directory).catch(() => undefined))?.isDirectory()) {
-      throw new WorkspaceOperationError("workspace-path-not-found", `Den Ordner ${requested} gibt es nicht`, 404);
+      throw new WorkspaceOperationError("workspace-path-not-found", `The folder ${requested} does not exist`, 404);
     }
     return execute(toolCallId, { ...params, cwd: directory }, signal, onUpdate);
   };
 
   const startBash: BashOperations["exec"] = async (command, commandCwd, options) => {
-      if (shuttingDown) throw new Error("Die Werkzeuge werden killed");
+      if (shuttingDown) throw new Error("The tools are being killed");
       const context = await contextFor();
-      if (shuttingDown) throw new Error("Die Werkzeuge werden killed");
+      if (shuttingDown) throw new Error("The tools are being killed");
       options.signal?.throwIfAborted();
       const bash = bashLaunch({ bash: context.bash, rg: context.rg }, command, context.env);
       const launch = await sandboxedLaunch(context, bash);
-      if (shuttingDown) throw new Error("Die Werkzeuge werden killed");
+      if (shuttingDown) throw new Error("The tools are being killed");
       options.signal?.throwIfAborted();
+      const marker = onWindows ? randomUUID() : undefined;
       return new Promise((resolve, reject) => {
         const child = spawn(launch.command, [...launch.args], {
           cwd: commandCwd,
           detached: !onWindows,
           stdio: ["ignore", "pipe", "pipe"],
-          env: bash.env,
+          env: marker === undefined ? bash.env : { ...bash.env, [MSYS_CALL_ENV]: marker },
           uid: context.uid,
           gid: context.gid,
           windowsHide: true,
         });
         if (child.pid) processGroups.add(child.pid);
+        if (child.pid && marker !== undefined && context.bash !== undefined) msysCalls.set(child.pid, { bash: context.bash, env: context.env, marker });
         child.stdout?.on("data", options.onData);
         child.stderr?.on("data", options.onData);
         let killed = false;
@@ -294,7 +300,7 @@ export const createSandboxTools = async (
               child.kill("SIGKILL");
             } catch (failure) {
               cleanup();
-              reject(new AggregateError([error, failure], "Bash-Prozess konnte nicht beendet werden"));
+              reject(new AggregateError([error, failure], "Bash process could not be ended"));
             }
           });
         };
@@ -333,8 +339,8 @@ export const createSandboxTools = async (
 
   const bashOperations: BashOperations = {
     exec: (command, commandCwd, options) => {
-      if (shuttingDown) throw new Error("Die Werkzeuge werden killed");
-      if (options.signal?.aborted) throw new Error("Abgebrochen");
+      if (shuttingDown) throw new Error("The tools are being killed");
+      if (options.signal?.aborted) throw new Error("Cancelled");
       return startBash(command, commandCwd, options);
     },
   };
@@ -353,16 +359,16 @@ export const createSandboxTools = async (
   };
 };
 
-/** Die Operationen des Moduls heißen wie die Werkzeuge, die das Modell sieht. */
+/** The operations of the module are named like the tools the model sees. */
 export const SANDBOX_TOOL_NAMES = ["read", "edit", "write", "bash"] as const;
 
-/** Eine ausdrücklich verlangte Zeitgrenze in Sekunden verlängert, wie lange ein entfernter Executor auf die Bash warten darf. */
+/** An explicitly requested timeout in seconds extends how long a remote executor may wait for the bash. */
 const bashDuration = (input: unknown): { durationMs?: number } => {
   const seconds = typeof input === "object" && input !== null ? (input as { timeout?: unknown }).timeout : undefined;
   return typeof seconds === "number" && seconds > 0 ? { durationMs: seconds * 1000 } : {};
 };
 
-/** Die Dateiwerkzeuge sprechen die Wurzel ihres Pfads an, Bash die ihres Ordners und ohne Ordner keine bestimmte. */
+/** The file tools address the root of their path, bash the root of its folder and without a folder no specific one. */
 const sandboxToolFootprints: Readonly<Record<(typeof SANDBOX_TOOL_NAMES)[number], (input: unknown) => OperationFootprint>> = {
   read: (input) => ({ roots: rootsOfFields(input, "path") }),
   edit: (input) => ({ roots: rootsOfFields(input, "path") }),
@@ -376,7 +382,7 @@ const textOf = (update: ToolUpdate): string =>
     .map((part) => part.text)
     .join("\n");
 
-/** Die vier Sandbox-Werkzeuge als Operationen; die Sandbox eines Runs entsteht beim ersten Aufruf, Bash meldet ihre Ausgabe als `{ text }`. */
+/** The four sandbox tools as operations; the sandbox of a run is created on the first call, bash reports its output as `{ text }`. */
 export const sandboxToolsModule: WorkspaceModuleFactory = (host) => {
   const sandboxes = new Map<string, Promise<SandboxTools>>();
   const sandboxOf = (runId: string): Promise<SandboxTools> => {
@@ -401,7 +407,7 @@ export const sandboxToolsModule: WorkspaceModuleFactory = (host) => {
   const operation = (name: string): WorkspaceOperation => async ({ runId, input, toolCallId, signal, progress }) => {
     const { tools } = await sandboxOf(runId);
     const run = tools.get(name);
-    if (!run) throw new Error(`Die Sandbox kennt das Werkzeug ${name} nicht`);
+    if (!run) throw new Error(`The sandbox does not know the tool ${name}`);
     return run(input, {
       toolCallId: toolCallId ?? name,
       ...(signal ? { signal } : {}),

package/packages/workspace-executor/src/session-ident.ts

@@ -20,7 +20,7 @@ const processes = async (uid: number): Promise<number[]> => {
 };
 
 export const stopUidProcesses = async (uid: number): Promise<void> => {
-  for (let versuch = 0; versuch < 20; versuch++) {
+  for (let attempt = 0; attempt < 20; attempt++) {
     const pids = await processes(uid);
     if (pids.length === 0) return;
     for (const pid of pids) {
@@ -33,5 +33,5 @@ export const stopUidProcesses = async (uid: number): Promise<void> => {
     await new Promise((resolve) => setTimeout(resolve, 10));
   }
   const pids = await processes(uid);
-  if (pids.length > 0) throw new Error(`Prozesse mit UID ${uid} konnten nicht beendet werden: ${pids.join(", ")}`);
+  if (pids.length > 0) throw new Error(`Processes with UID ${uid} could not be ended: ${pids.join(", ")}`);
 };

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

@@ -9,14 +9,14 @@ const searchTexts = {
   grep: "`rg` (ripgrep) is not available here. `grep -r` also walks dependency and build folders, so exclude them: `grep -r --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=bin --exclude-dir=obj ...`.",
 };
 
-/** Was der Executor dem Werkzeug bash über die Plattform hinaus bietet. */
+/** What the executor offers the bash tool beyond the platform. */
 export interface ShellTools {
   readonly ripgrep: boolean;
 }
 
 export const shellPlatformText = (platform: NodeJS.Platform, tools: ShellTools): string => {
   const text = platformTexts[platform];
-  if (!text) throw new Error(`Für die Plattform ${platform} gibt es keine Shell-Beschreibung.`);
+  if (!text) throw new Error(`There is no shell description for the platform ${platform}.`);
   const search = tools.ripgrep ? searchTexts.ripgrep : searchTexts.grep;
   return `${text} ${search} A nonzero exit code, for example \`grep\` without a match, comes back as an ordinary result with the code at the end, not as a tool error; only start, timeout and abort problems are tool errors.`;
 };

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

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import path from "node:path";
 
-/** Unter Windows liegen die Daten in `%LOCALAPPDATA%\ragents`, sonst unter `~/.local/share/ragents`. */
+/** On Windows the data lives in `%LOCALAPPDATA%\ragents`, otherwise under `~/.local/share/ragents`. */
 export const ragentsDataRoot = (
   home = homedir(),
   platform: NodeJS.Platform = process.platform,
@@ -9,17 +9,17 @@ export const ragentsDataRoot = (
 ): string => {
   if (platform !== "win32") return path.resolve(home, ".local/share/ragents");
   const local = environment.LOCALAPPDATA;
-  if (!local) throw new Error("LOCALAPPDATA ist nicht gesetzt; unter Windows liegt der Datenordner in %LOCALAPPDATA%\\ragents.");
+  if (!local) throw new Error("LOCALAPPDATA is not set; on Windows the data folder is in %LOCALAPPDATA%\\ragents.");
   return path.join(local, "ragents");
 };
 
-/** Der Werkzeugordner eines Plugins: was seine Provisionierung auf diese Maschine legt. */
+/** The tools folder of a plugin: what its provisioning puts on this machine. */
 export const pluginToolsDirectory = (dataDirectory: string, pluginId: string): string =>
   path.join(dataDirectory, "tools", pluginId);
 
-/** Ein Arbeitsplatz hat kein Profil; seine Werkzeuge liegen in einem eigenen Datenordner neben denen der Profile. */
+/** A workspace has no profile; its tools live in a data folder of its own next to those of the profiles. */
 export const workspaceDataDirectory = (home = homedir()): string => path.join(ragentsDataRoot(home), "workspace");
 
-/** Der Datenordner dieses Prozesses: DATA_DIR wie beim Server, sonst der des Arbeitsplatzes ohne Profil. */
+/** The data folder of this process: DATA_DIR as on the server, otherwise the one of the workspace without a profile. */
 export const hostDataDirectory = (environment: NodeJS.ProcessEnv = process.env): string =>
   path.resolve(environment.DATA_DIR ?? workspaceDataDirectory());

package/plugins/ragents.activity/web/ActivityHeader.tsx

@@ -14,7 +14,7 @@ const kindLabels: Readonly<Record<ActivityEntry["kind"], string>> = {
 };
 
 const titleOf = (entry: ActivityEntry) =>
-  entry.kind === "tool" ? `Werkzeug läuft: ${entry.label}` : `Turn läuft: ${entry.label}`;
+  entry.kind === "tool" ? `Tool running: ${entry.label}` : `Turn running: ${entry.label}`;
 
 export function ActivityHeader({ session }: SessionHeaderContext) {
   const state = useMemo(
@@ -34,7 +34,7 @@ export function ActivityHeader({ session }: SessionHeaderContext) {
   if (!active) return null;
 
   return (
-    <div aria-label="Was gerade läuft" className="flex min-w-0 flex-none items-stretch self-stretch" role="status">
+    <div aria-label="What is running right now" className="flex min-w-0 flex-none items-stretch self-stretch" role="status">
       {state.entries.map((entry) => {
         const elapsed = elapsedLabel(entry.startedAt, now);
         return (
@@ -51,7 +51,7 @@ export function ActivityHeader({ session }: SessionHeaderContext) {
         );
       })}
       {state.hidden > 0 && (
-        <ToolbarItem className="text-muted-foreground">+{state.hidden} weitere</ToolbarItem>
+        <ToolbarItem className="text-muted-foreground">+{state.hidden} more</ToolbarItem>
       )}
     </div>
   );

package/plugins/ragents.activity/web/activity.ts

@@ -72,7 +72,7 @@ const turnFrom = (value: unknown): ActivityTurn[] => {
   }];
 };
 
-/** Liest Actors und Turns aus der Run-Ansicht; eine noch nicht geladene oder fremde Struktur ergibt nichts. */
+/** Reads actors and turns from the run view; a structure that is not loaded yet or unknown yields nothing. */
 export const activitySourceFrom = (
   runView: unknown,
 ): ActivitySource => {
@@ -120,7 +120,7 @@ const runningTurns = (source: ActivitySource): ActivityEntry[] =>
     }];
   });
 
-/** Der Ist-Zustand: offene Werkzeugaufrufe zuerst, dann laufende Turns, jeweils das Älteste voran. */
+/** The current state: open tool calls first, then running turns, oldest first in each group. */
 export const activeActivity = (source: ActivitySource): ActivityState => {
   const entries = [
     ...runningTools(source).sort(byStart),

package/plugins/ragents.actor-programs/server/access-projections.ts

@@ -0,0 +1,31 @@
+import type { AccessProjectionContribution, JsonValue } from "@ragents/engine";
+import { ACTOR_INVOCATIONS_STATE_ID, ACTOR_PROGRAMS_STATE_ID } from "@ragents/host/plugin-support/actor-programs/contract.js";
+
+const record = (value: JsonValue | undefined): Record<string, JsonValue | undefined> | undefined =>
+  value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+
+/** Without runs.inspect, only the name, actor, and views of a program remain; sources, functions, and directories are missing. */
+const visibleProgram = (state: JsonValue): JsonValue => {
+  const program = record(record(state)?.program);
+  if (!program) return state;
+  const views = Array.isArray(program.views) ? program.views.map((value) => {
+    const view = record(value);
+    return view ? { id: view.id, key: view.key, title: view.title, visible: view.visible, placements: view.placements } : value;
+  }) : [];
+  return {
+    version: 1,
+    program: {
+      name: program.name,
+      title: program.title,
+      actorId: program.actorId,
+      actorHandle: program.actorHandle,
+      revision: program.revision,
+      views,
+    },
+  };
+};
+
+export const actorProgramAccessProjections: readonly AccessProjectionContribution[] = [
+  { id: ACTOR_PROGRAMS_STATE_ID, state: (entry) => visibleProgram(entry.state), chatEvent: () => undefined },
+  { id: ACTOR_INVOCATIONS_STATE_ID, state: (entry) => ({ version: 1, revision: entry.updatedAt }), chatEvent: () => undefined },
+];

package/plugins/ragents.actor-programs/server/agent-tools.ts

@@ -7,7 +7,7 @@ export const agentToolsFrom = (host: PluginHost) =>
     const view = runtime.view(runId);
     const actor = provisional ?? view.actors.find((candidate) => candidate.id === actorId);
     if (!actor || actor.kind === "human" || actor.lifecycle.kind === "stopped") {
-      throw new Error(`${actorId} bezeichnet keinen aktiven Agenten in diesem Run.`);
+      throw new Error(`${actorId} does not denote an active agent in this run.`);
     }
     const registry = new ToolRegistry();
     host.tools.entries().forEach((contributor) => registry.register(contributor));
@@ -24,7 +24,7 @@ export const agentToolsFrom = (host: PluginHost) =>
     const availableNames = new Set(tools.map((tool) => tool.name));
     const unknown = actor.toolNames.filter((name) => !availableNames.has(name));
     if (unknown.length > 0) {
-      throw new Error(`Actor ${actorId} verlangt unbekannte Werkzeuge: ${unknown.join(", ")}.`);
+      throw new Error(`Actor ${actorId} requires unknown tools: ${unknown.join(", ")}.`);
     }
     const selected = new Set(actor.toolNames);
     return tools.filter((tool) => selected.has(tool.name));

package/plugins/ragents.actor-programs/server/capability-resolver.ts

@@ -37,7 +37,7 @@ const selected = <T>(
   const byId = new Map(available.map((value) => [idOf(value), value]));
   return capabilityIds.map((id) => {
     const value = byId.get(id);
-    if (!value) throw unavailable(id, [...byId.keys()].sort().join(", ") || "keine");
+    if (!value) throw unavailable(id, [...byId.keys()].sort().join(", ") || "none");
     return value;
   });
 };
@@ -51,7 +51,7 @@ export const operatorCapabilityBinding = (
     operations.filter((operation) => operation.operator !== "unavailable"),
     capabilityIds,
     (operation) => operation.id,
-    (id, names) => new Error(`Capability ${id} ist für den Bediener nicht verfügbar. Verfügbar sind: ${names}.`),
+    (id, names) => new Error(`Capability ${id} is not available to the operator. Available: ${names}.`),
   );
   const descriptors = resolved.map(descriptorOf);
   return {
@@ -76,7 +76,7 @@ export const agentCapabilityBinding = (
     capabilityIds,
     (tool) => tool.name,
     (id, names) => new Error(
-      `Capability ${id} ist für @${actor.handle} nicht verfügbar. Verfügbar sind: ${names}.`,
+      `Capability ${id} is not available to @${actor.handle}. Available: ${names}.`,
     ),
   );
   const descriptors = resolved.map((tool) => descriptorOf({ ...tool, id: tool.name }));