@schlenkr/ragents 0.1.10 → 0.1.12

package/bundles/ragents.actor-programs/server/index.js

@@ -14,7 +14,7 @@ var agentToolsFrom = (host) => async (runId, actorId, provisional) => {
   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));
@@ -31,7 +31,7 @@ var agentToolsFrom = (host) => async (runId, actorId, provisional) => {
   const availableNames = new Set(tools.map((tool) => tool.name));
   const unknown = actor.toolNames.filter((name2) => !availableNames.has(name2));
   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 selected2 = new Set(actor.toolNames);
   return tools.filter((tool) => selected2.has(tool.name));
@@ -51,7 +51,7 @@ var guarded = (code, status, work) => {
 };
 var checkedInput = (input) => {
   if (Buffer.byteLength(JSON.stringify(input ?? null), "utf8") > MAX_INPUT_BYTES)
-    throw new DomainError("input-too-large", `Die Aktionseingabe ist gr\xF6\xDFer als ${MAX_INPUT_BYTES} Byte.`, 413);
+    throw new DomainError("input-too-large", `The action input is larger than ${MAX_INPUT_BYTES} bytes.`, 413);
   return input;
 };
 var createActorProgramMethods = (options) => {
@@ -112,7 +112,7 @@ var escapeForwarder = `
   });`;
 var themeReceiver = `
   const applyHostTheme = (theme) => {
-    if (theme !== "light" && theme !== "dark") throw new Error("Das Host-Theme muss light oder dark sein.");
+    if (theme !== "light" && theme !== "dark") throw new Error("The host theme must be light or dark.");
     document.documentElement.dataset.theme = theme;
   };`;
 var frameContentSecurityPolicy = (nonce) => `sandbox allow-scripts allow-forms allow-downloads; default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; img-src 'self' data: blob:; font-src data:; connect-src 'none'; media-src 'self' data: blob:; object-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'self' https://*.vscode-cdn.net vscode-file: vscode-webview:`;
@@ -156,7 +156,7 @@ globalThis.__ragentsAppContext = (() => {
     if (!waiter || !terminal.has(message.invocation.status)) return;
     pending.delete(id);
     if (message.invocation.status === "succeeded") waiter.resolve(message.invocation.result);
-    else waiter.reject(new Error(message.invocation.error || "Die App-Aktion wurde nicht abgeschlossen."));
+    else waiter.reject(new Error(message.invocation.error || "The app action was not completed."));
   };
   port.onmessage = ({ data }) => {
     if (data?.version !== 1) return;
@@ -218,7 +218,7 @@ globalThis.__ragentsAppContext = (() => {
     );
   }
   return Object.freeze({
-    get actor() { if (!currentApp) throw new Error("Die Actor-Ansicht ist noch nicht bereit."); return Object.freeze({id:currentApp.actorId,handle:currentApp.actorHandle}); },
+    get actor() { if (!currentApp) throw new Error("The actor view is not ready yet."); return Object.freeze({id:currentApp.actorId,handle:currentApp.actorHandle}); },
     ready: ready.then(() => undefined),
     run: Object.freeze({ id: "current" }),
     principal: Object.freeze({ id: "operator", kind: "operator" }),
@@ -264,7 +264,7 @@ globalThis.__ragentsAppContext = (() => {
       call: async (actionId, input = {}) => {
         await ready;
         if (!(currentApp?.actions ?? []).some((action) => action.id === actionId)) {
-          throw new Error("Die angeforderte App-Aktion ist nicht installiert.");
+          throw new Error("The requested app action is not installed.");
         }
         return send({
           type: "ragents.app.invoke",
@@ -280,7 +280,7 @@ globalThis.__ragentsAppContext = (() => {
 </script>`;
 var frameHtml = (frame, nonce) => {
   const head = /<head(?:\s[^>]*)?>/i;
-  if (!head.test(frame.html)) throw new Error("Die installierte App besitzt keinen g\xFCltigen head.");
+  if (!head.test(frame.html)) throw new Error("The installed app has no valid head.");
   const client = `<script nonce="${nonce}" type="module">await globalThis.__ragentsAppContext.ready;${escapedScript(frame.clientJavaScript)}</script>`;
   return frame.html.replace(head, (value) => `${value}${typedBridgeSdk(nonce, `${browserRuntimeStyles}
 ${frame.styles}`)}${client}`);
@@ -292,7 +292,7 @@ var createMiniAppFrameRoutes = (options) => [
     matches: (request, url) => request.method === "GET" && framePattern.test(url.pathname),
     handle: async ({ request, response, url }) => {
       const match = url.pathname.match(framePattern);
-      if (!match) throw new Error("Ung\xFCltige App-Route.");
+      if (!match) throw new Error("Invalid app route.");
       const [, runId, appId] = match;
       await guardedJsonRoute({
         request,
@@ -339,12 +339,12 @@ var jsonValue = (value, label) => {
   assertJsonValue(value, label);
   const text = JSON.stringify(value);
   if (Buffer.byteLength(text, "utf8") > MAX_JSON_BYTES)
-    throw new Error(`${label} ist gr\xF6\xDFer als ${MAX_JSON_BYTES} Byte.`);
+    throw new Error(`${label} is larger than ${MAX_JSON_BYTES} bytes.`);
   const pending = [{ value, depth: 0 }];
   while (pending.length > 0) {
     const current = pending.pop();
     if (current.depth > MAX_JSON_DEPTH)
-      throw new Error(`${label} ist tiefer als ${MAX_JSON_DEPTH} Ebenen verschachtelt.`);
+      throw new Error(`${label} is nested deeper than ${MAX_JSON_DEPTH} levels.`);
     if (Array.isArray(current.value)) {
       current.value.forEach((entry) => pending.push({ value: entry, depth: current.depth + 1 }));
       continue;
@@ -352,7 +352,7 @@ var jsonValue = (value, label) => {
     if (current.value && typeof current.value === "object") {
       Object.entries(current.value).forEach(([key, entry]) => {
         if (key.length > MAX_JSON_KEY_LENGTH)
-          throw new Error(`${label} enth\xE4lt einen Schl\xFCssel mit mehr als ${MAX_JSON_KEY_LENGTH} Zeichen.`);
+          throw new Error(`${label} contains a key with more than ${MAX_JSON_KEY_LENGTH} characters.`);
         pending.push({ value: entry, depth: current.depth + 1 });
       });
     }
@@ -376,7 +376,7 @@ var selected = (available2, capabilityIds, idOf, unavailable) => {
   const byId = new Map(available2.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;
   });
 };
@@ -385,7 +385,7 @@ var operatorCapabilityBinding = (actorId, operations, capabilityIds) => {
     operations.filter((operation) => operation.operator !== "unavailable"),
     capabilityIds,
     (operation) => operation.id,
-    (id, names) => new Error(`Capability ${id} ist f\xFCr den Bediener nicht verf\xFCgbar. Verf\xFCgbar sind: ${names}.`)
+    (id, names) => new Error(`Capability ${id} is not available to the operator. Available: ${names}.`)
   );
   const descriptors = resolved.map(descriptorOf);
   return {
@@ -404,7 +404,7 @@ var agentCapabilityBinding = (actor, tools, capabilityIds, blockedNames) => {
     capabilityIds,
     (tool) => tool.name,
     (id, names) => new Error(
-      `Capability ${id} ist f\xFCr @${actor.handle} nicht verf\xFCgbar. Verf\xFCgbar sind: ${names}.`
+      `Capability ${id} is not available to @${actor.handle}. Available: ${names}.`
     )
   );
   const descriptors = resolved.map((tool) => descriptorOf({ ...tool, id: tool.name }));
@@ -428,11 +428,11 @@ import { runManagedProcess, sandboxedLaunch } from "@ragents/workspace-executor"
 // server/controls-template.ts
 var controlsTemplate = {
   id: "controls",
-  title: "UI-Controls ausprobieren",
-  description: "Lokale Demo mit Formular, Tabelle, Dateien, Aufgaben, Ablaufdiagramm, SVG-Verbindungen, Nachrichten, Dokument und Diff ohne Funktionsaufrufe.",
+  title: "Try UI controls",
+  description: "Local demo with form, table, files, tasks, flow diagram, SVG connections, messages, document, and diff without function calls.",
   ragents: {
-    title: "UI-Controls ausprobieren",
-    description: "Eine lokale Demo der vorhandenen Mini-App-Controls. Werte und Dateien bleiben in dieser Ansicht.",
+    title: "Try UI controls",
+    description: "A local demo of the available mini-app controls. Values and files stay in this view.",
     views: [{ id: "main", client: "src/client.tsx" }]
   },
   files: {
@@ -443,67 +443,67 @@ import * as UI from "@ragents/client/ui";
 type FormValues = Parameters<typeof UI.Form>[0]["values"];
 type Row = { id: string; name: string; count: number };
 const rows: Row[] = [
-  { id: "analysis", name: "Analyse", count: 12 },
+  { id: "analysis", name: "Analysis", count: 12 },
   { id: "review", name: "Review", count: 4 },
-  { id: "notes", name: "Dokumentation", count: 8 },
+  { id: "notes", name: "Documentation", count: 8 },
 ];
 
 const App = () => {
-  const [values, setValues] = React.useState<FormValues>({ title: "Ergebnisse pr\xFCfen", notes: "", count: 3, mode: "review", approved: false });
+  const [values, setValues] = React.useState<FormValues>({ title: "Review results", notes: "", count: 3, mode: "review", approved: false });
   const [selected, setSelected] = React.useState<string[]>([]);
   const [files, setFiles] = React.useState<File[]>([]);
-  const [result, setResult] = React.useState("Noch keine Formularwerte \xFCbernommen.");
+  const [result, setResult] = React.useState("No form values applied yet.");
   const [messages, setMessages] = React.useState<Parameters<typeof UI.MessageList>[0]["messages"]>([
-    { key: "editorial", sender: "Redaktion", text: "Der Hinweis soll **kurz und verst\xE4ndlich** bleiben." },
-    { key: "review", sender: "Textpr\xFCfung", text: "\xD6ffnungszeiten und Reparaturhinweis bleiben erhalten." },
+    { key: "editorial", sender: "Editorial", text: "The notice should stay **short and clear**." },
+    { key: "review", sender: "Text review", text: "Opening hours and the repair notice are kept." },
   ]);
   const [done, setDone] = React.useState(false);
-  return <UI.AppLayout title="UI-Controls ausprobieren" description="Lokale Demo: keine Agenten, Uploads oder Serveraktionen. Werte und Dateiauswahl bleiben nur in dieser Ansicht und werden beim Neuladen zur\xFCckgesetzt.">
+  return <UI.AppLayout title="Try UI controls" description="Local demo: no agents, uploads, or server actions. Values and file selection stay only in this view and are reset on reload.">
     <UI.Stack gap="large">
-      <UI.Form title="Formular" fields={[
-        { id: "title", label: "Auftrag", type: "text", placeholder: "Was soll bearbeitet werden?", required: true },
-        { id: "notes", label: "Hinweise", type: "textarea", rows: 3, placeholder: "Was soll bei der Bearbeitung ber\xFCcksichtigt werden?", hint: "Mehrzeiliger Text bleibt im Formular ausgerichtet." },
-        { id: "count", label: "Anzahl", type: "number", placeholder: "Anzahl der Ergebnisse", hint: "1 bis 10 Ergebnisse.", required: true, min: 1, max: 10 },
-        { id: "mode", label: "Modus", type: "select", options: [{ value: "review", label: "Pr\xFCfen" }, { value: "draft", label: "Entwerfen" }] },
-        { id: "approved", label: "Auswahl best\xE4tigt", type: "checkbox", required: true },
-      ]} values={values} onChange={setValues} onSubmit={async (next) => { setResult(JSON.stringify(next, null, 2)); }} submitLabel="Werte lokal anzeigen" />
+      <UI.Form title="Form" fields={[
+        { id: "title", label: "Task", type: "text", placeholder: "What should be worked on?", required: true },
+        { id: "notes", label: "Notes", type: "textarea", rows: 3, placeholder: "What should be taken into account while working on it?", hint: "Multi-line text stays aligned in the form." },
+        { id: "count", label: "Count", type: "number", placeholder: "Number of results", hint: "1 to 10 results.", required: true, min: 1, max: 10 },
+        { id: "mode", label: "Mode", type: "select", options: [{ value: "review", label: "Review" }, { value: "draft", label: "Draft" }] },
+        { id: "approved", label: "Selection confirmed", type: "checkbox", required: true },
+      ]} values={values} onChange={setValues} onSubmit={async (next) => { setResult(JSON.stringify(next, null, 2)); }} submitLabel="Show values locally" />
       <UI.Stack gap="small">
-        <UI.DataTable<Row> title="Datentabelle" rows={rows} rowKey={(row) => row.id} filterable
+        <UI.DataTable<Row> title="Data table" rows={rows} rowKey={(row) => row.id} filterable
           selectedKeys={selected} onSelectionChange={setSelected}
-          columns={[{ id: "name", label: "Arbeit", value: (row) => row.name, sortable: true }, { id: "count", label: "Ergebnisse", value: (row) => row.count, sortable: true }]}
-          actions={[{ id: "select", label: "Ausw\xE4hlen", onClick: (row) => { setSelected([row.id]); } }]} />
-        <p aria-live="polite">{selected.length} Zeilen ausgew\xE4hlt</p>
+          columns={[{ id: "name", label: "Work", value: (row) => row.name, sortable: true }, { id: "count", label: "Results", value: (row) => row.count, sortable: true }]}
+          actions={[{ id: "select", label: "Select", onClick: (row) => { setSelected([row.id]); } }]} />
+        <p aria-live="polite">{selected.length} rows selected</p>
       </UI.Stack>
-      <UI.FilePicker label="Lokale Dateiauswahl" files={files} onChange={setFiles} maxFiles={5} maxBytes={10 * 1024 * 1024} />
+      <UI.FilePicker label="Local file selection" files={files} onChange={setFiles} maxFiles={5} maxBytes={10 * 1024 * 1024} />
       <UI.Stack gap="small">
-        <UI.TaskProgress title="Beispielaufgaben" tasks={[
-          { id: "read", label: "Unterlagen lesen", status: "done" },
-          { id: "review", label: "Ergebnisse pr\xFCfen", status: done ? "done" : "pending", description: "Lokaler Beispielstatus, kein laufender Actor." },
+        <UI.TaskProgress title="Example tasks" tasks={[
+          { id: "read", label: "Read documents", status: "done" },
+          { id: "review", label: "Review results", status: done ? "done" : "pending", description: "Local example status, no running actor." },
         ]} />
-        <UI.Stack direction="row"><UI.Button onClick={() => setDone((current) => !current)}>Beispielstatus umschalten</UI.Button></UI.Stack>
+        <UI.Stack direction="row"><UI.Button onClick={() => setDone((current) => !current)}>Toggle example status</UI.Button></UI.Stack>
       </UI.Stack>
       <UI.Stack gap="small">
-        <h2>Ablaufdiagramm</h2>
-        <p>Das Diagramm erh\xE4lt seinen Zustand aus denselben Daten wie die Aufgabenliste.</p>
-        <UI.FlowDiagram label={done ? "Eingang, Pr\xFCfung fertig, Ergebnis bereit" : "Eingang, Pr\xFCfung l\xE4uft, Ergebnis ausstehend"}
+        <h2>Flow diagram</h2>
+        <p>The diagram gets its state from the same data as the task list.</p>
+        <UI.FlowDiagram label={done ? "Intake, review done, result ready" : "Intake, review running, result pending"}
           nodes={[
-            { id: "input", label: "Eingang", detail: "Unterlagen liegen vor", status: "done", kind: "service" },
-            { id: "check", label: "Pr\xFCfung", detail: done ? "Pr\xFCfung abgeschlossen" : "Unterlagen werden gepr\xFCft", status: done ? "done" : "active", kind: "agent" },
-            { id: "result", label: "Ergebnis", detail: done ? "Ergebnis bereit" : "Wartet auf die Pr\xFCfung", status: done ? "done" : "pending", kind: "actor" },
+            { id: "input", label: "Intake", detail: "Documents are available", status: "done", kind: "service" },
+            { id: "check", label: "Review", detail: done ? "Review completed" : "Documents are being reviewed", status: done ? "done" : "active", kind: "agent" },
+            { id: "result", label: "Result", detail: done ? "Result ready" : "Waiting for the review", status: done ? "done" : "pending", kind: "actor" },
           ]}
           edges={[{ source: "input", target: "check" }, { source: "check", target: "result" }]} />
       </UI.Stack>
       <UI.Stack gap="small">
-        <h2>SVG-Verbindungen</h2>
-        <p>SvgEdge zeichnet die Kanten. Knoten, Beschriftungen und Positionen stehen im Code dieser Ansicht.</p>
-        <svg viewBox="0 0 360 160" role="img" aria-label={done ? "Eingang fertig, Pr\xFCfung abgeschlossen, Ergebnis bereit" : "Eingang fertig, Pr\xFCfung l\xE4uft, Ergebnis offen"}
+        <h2>SVG connections</h2>
+        <p>SvgEdge draws the edges. Nodes, labels, and positions are in the code of this view.</p>
+        <svg viewBox="0 0 360 160" role="img" aria-label={done ? "Intake done, review completed, result ready" : "Intake done, review running, result open"}
           className="block h-auto w-full text-[13px]">
           <UI.SvgEdge d="M112 42 L144 42" tone={done ? "success" : "warning"} active={!done} />
           <UI.SvgEdge d="M252 42 C320 42 320 118 252 118" arrow={done ? "end" : "none"} tone={done ? "success" : "neutral"} lineStyle={done ? "solid" : "dashed"} />
           <UI.SvgEdge d="M144 118 C64 118 64 96 64 72" arrow="both" tone="accent" />
-          {[{ x: 8, y: 12, label: "Eingang", status: "Fertig" },
-            { x: 148, y: 12, label: "Pr\xFCfung", status: done ? "Fertig" : "L\xE4uft" },
-            { x: 148, y: 88, label: "Ergebnis", status: done ? "Bereit" : "Offen" }].map((node) => <g key={node.label}>
+          {[{ x: 8, y: 12, label: "Intake", status: "Done" },
+            { x: 148, y: 12, label: "Review", status: done ? "Done" : "Running" },
+            { x: 148, y: 88, label: "Result", status: done ? "Ready" : "Open" }].map((node) => <g key={node.label}>
               <rect x={node.x} y={node.y} width="104" height="56" rx="8" className="fill-background stroke-border-strong" />
               <text x={node.x + 52} y={node.y + 23} textAnchor="middle" className="fill-foreground font-semibold">{node.label}</text>
               <text x={node.x + 52} y={node.y + 42} textAnchor="middle" className="fill-muted-foreground text-[11px]">{node.status}</text>
@@ -511,20 +511,20 @@ const App = () => {
         </svg>
       </UI.Stack>
       <UI.Stack gap="small">
-        <UI.MessageList messages={messages} label="Lokale Redaktionsnotizen" />
+        <UI.MessageList messages={messages} label="Local editorial notes" />
         <UI.Stack direction="row"><UI.Button onClick={() => setMessages((current) => [...current, {
-          key: "note-" + current.length, sender: current.length % 2 ? "Textpr\xFCfung" : "Redaktion",
-          text: "Lokale Beispielnotiz " + (current.length - 1) + ": Diese Nachricht wurde gerade erg\xE4nzt.",
-        }])}>Lokale Nachricht erg\xE4nzen</UI.Button></UI.Stack>
+          key: "note-" + current.length, sender: current.length % 2 ? "Text review" : "Editorial",
+          text: "Local example note " + (current.length - 1) + ": This message was just added.",
+        }])}>Add local message</UI.Button></UI.Stack>
       </UI.Stack>
-      <UI.DocumentViewer title="Lokales Formularergebnis" format="text" content={result} />
-      <UI.DiffViewer title="Beispiel\xE4nderung" patch={"--- a/result.txt\\n+++ b/result.txt\\n@@ -1 +1 @@\\n-Status: offen\\n+Status: gepr\xFCft"} />
+      <UI.DocumentViewer title="Local form result" format="text" content={result} />
+      <UI.DiffViewer title="Example change" patch={"--- a/result.txt\\n+++ b/result.txt\\n@@ -1 +1 @@\\n-Status: open\\n+Status: reviewed"} />
     </UI.Stack>
   </UI.AppLayout>;
 };
 
 const root = document.getElementById("root");
-if (!root) throw new Error("Das Wurzelelement #root fehlt.");
+if (!root) throw new Error("The #root element is missing.");
 createRoot(root).render(<App />);
 `
   }
@@ -533,11 +533,11 @@ createRoot(root).render(<App />);
 // server/templates.ts
 var blank = {
   id: "blank",
-  title: "Leere Mini-App",
-  description: "Eine reine React-View am vorhandenen Actor ohne zus\xE4tzliche Serverfunktion.",
+  title: "Blank mini-app",
+  description: "A pure React view on the existing actor without an additional server function.",
   ragents: {
-    title: "Meine View",
-    description: "Eine kleine Bedienoberfl\xE4che des vorhandenen Actors.",
+    title: "My view",
+    description: "A small interface of the existing actor.",
     views: [{ id: "main", client: "src/client.tsx" }]
   },
   files: {
@@ -545,24 +545,24 @@ var blank = {
 import * as UI from "@ragents/client/ui";
 
 const App = () => (
-  <UI.AppLayout title="Meine View">
-    <UI.Stack><p>Bereit f\xFCr deine Inhalte.</p></UI.Stack>
+  <UI.AppLayout title="My view">
+    <UI.Stack><p>Ready for your content.</p></UI.Stack>
   </UI.AppLayout>
 );
 
 const root = document.getElementById("root");
-if (!root) throw new Error("Das Wurzelelement #root fehlt.");
+if (!root) throw new Error("The #root element is missing.");
 createRoot(root).render(<App />);
 `
   }
 };
 var chat = {
   id: "chat",
-  title: "Actor-Chat",
-  description: "Wiederverwendbarer Chat mit Verlauf und optionaler Eingabe an den Actor dieser View.",
+  title: "Actor chat",
+  description: "Reusable chat with history and optional input to the actor of this view.",
   ragents: {
-    title: "Actor-Chat",
-    description: "Zeigt das Gespr\xE4ch mit einem Actor und sendet ihm Benutzereingaben.",
+    title: "Actor chat",
+    description: "Shows the conversation with an actor and sends it user input.",
     views: [{ id: "main", client: "src/client.tsx" }]
   },
   files: {
@@ -571,22 +571,22 @@ import * as UI from "@ragents/client/ui";
 import { context } from "@ragents/client";
 
 const App = () => (
-  <UI.Chat actor={"@" + context.actor.handle} className="h-full" showInput placeholder="Nachricht an den Actor" />
+  <UI.Chat actor={"@" + context.actor.handle} className="h-full" showInput placeholder="Message to the actor" />
 );
 
 const root = document.getElementById("root");
-if (!root) throw new Error("Das Wurzelelement #root fehlt.");
+if (!root) throw new Error("The #root element is missing.");
 createRoot(root).render(<App />);
 `
   }
 };
 var textAnalysis = {
   id: "text-analysis",
-  title: "Textanalyse",
-  description: "Ein TypeScript-Actor analysiert Texte mit eigener Funktion, Zustand und React-View.",
+  title: "Text analysis",
+  description: "A TypeScript actor analyzes texts with its own function, state, and React view.",
   ragents: {
-    title: "Textanalyse",
-    description: "Z\xE4hlt Zeichen, W\xF6rter und Zeilen und merkt sich die Zahl der Analysen.",
+    title: "Text analysis",
+    description: "Counts characters, words, and lines and remembers the number of analyses.",
     backend: "src/server.ts",
     views: [{ id: "main", client: "src/client.tsx" }]
   },
@@ -601,23 +601,23 @@ type FormValues = Parameters<typeof UI.Form>[0]["values"];
 const App = () => {
   const state = useAppState();
   const [values, setValues] = React.useState<FormValues>({ text: "" });
-  const [result, setResult] = React.useState("Bereit");
+  const [result, setResult] = React.useState("Ready");
 
   const analyse = async (next: FormValues): Promise<void> => {
     const answer = await context.capabilities.call("analyse", { text: String(next.text ?? "") });
     setResult([
-      \`Zeichen: \${answer.characters}\`,
-      \`W\xF6rter: \${answer.words}\`,
-      \`Zeilen: \${answer.lines}\`,
+      \`Characters: \${answer.characters}\`,
+      \`Words: \${answer.words}\`,
+      \`Lines: \${answer.lines}\`,
     ].join("\\n"));
   };
 
   return (
-    <UI.AppLayout title="Textanalyse" description={<>Analysen: {state.analyses ?? 0}</>}>
+    <UI.AppLayout title="Text analysis" description={<>Analyses: {state.analyses ?? 0}</>}>
       <UI.Grid>
         <UI.Form fields={[
-          { id: "text", label: "Text", type: "textarea", rows: 6, placeholder: "Text eingeben" },
-        ]} values={values} onChange={setValues} onSubmit={analyse} submitLabel="Analysieren" />
+          { id: "text", label: "Text", type: "textarea", rows: 6, placeholder: "Enter text" },
+        ]} values={values} onChange={setValues} onSubmit={analyse} submitLabel="Analyze" />
         <UI.Stack><pre aria-live="polite" className="min-h-[90px] overflow-auto rounded-md border border-border bg-muted p-2.5 font-mono whitespace-pre-wrap">{result}</pre></UI.Stack>
       </UI.Grid>
     </UI.AppLayout>
@@ -625,7 +625,7 @@ const App = () => {
 };
 
 const root = document.getElementById("root");
-if (!root) throw new Error("Das Wurzelelement #root fehlt.");
+if (!root) throw new Error("The #root element is missing.");
 createRoot(root).render(<App />);
 `,
     "src/contract.ts": `import { Type } from "typebox";
@@ -634,10 +634,10 @@ export const contract = {
   state: Type.Object({ analyses: Type.Optional(Type.Integer({"minimum": 0})) }, {"additionalProperties": false}),
   functions: {
     analyse: {
-      label: "Text analysieren",
-      description: "Z\xE4hlt W\xF6rter, Zeichen und Zeilen ohne externe Wirkung.",
+      label: "Analyze text",
+      description: "Counts words, characters, and lines without external effects.",
       tool: { name: "analyse_text" },
-      input: Type.Object({ text: Type.String({"description": "Der zu analysierende Text."}) }, {"additionalProperties": false}),
+      input: Type.Object({ text: Type.String({"description": "The text to analyze."}) }, {"additionalProperties": false}),
       output: Type.Object({ text: Type.String(), characters: Type.Integer({"minimum": 0}), words: Type.Integer({"minimum": 0}), lines: Type.Integer({"minimum": 0}), analyses: Type.Integer({"minimum": 1}) }, {"additionalProperties": false}),
       capabilities: [],
     },
@@ -673,9 +673,9 @@ import { createTestContext } from "@ragents/server/testing";
 import { contract } from "../src/contract.ts";
 import program from "../src/server.ts";
 
-test("z\xE4hlt W\xF6rter, Zeilen und weitere Analysen", async () => {
+test("counts words, lines, and further analyses", async () => {
   const context = createTestContext<Static<typeof contract.state>>({ state: {} });
-  assert.deepEqual(await program.functions.analyse({"text": "  Hallo Welt\\nNeue Zeile  "}, context), {"text": "Hallo Welt\\nNeue Zeile", "characters": 21, "words": 4, "lines": 2, "analyses": 1});
+  assert.deepEqual(await program.functions.analyse({"text": "  Hello world\\nNew line  "}, context), {"text": "Hello world\\nNew line", "characters": 20, "words": 4, "lines": 2, "analyses": 1});
   assert.deepEqual(await program.functions.analyse({"text": ""}, context), {"text": "", "characters": 0, "words": 0, "lines": 0, "analyses": 2});
   assert.deepEqual(context.state.read(), {"analyses": 2});
 });
@@ -684,11 +684,11 @@ test("z\xE4hlt W\xF6rter, Zeilen und weitere Analysen", async () => {
 };
 var headlessCounter = {
   id: "headless-counter",
-  title: "Z\xE4hler ohne Oberfl\xE4che",
-  description: "Ein TypeScript-Actor z\xE4hlt Eingaben in seinem Zustand und bietet dieselbe Arbeit als Funktion an.",
+  title: "Counter without interface",
+  description: "A TypeScript actor counts inputs in its state and offers the same work as a function.",
   ragents: {
-    title: "Z\xE4hler",
-    description: "Sammelt eingehende Texte ohne Modellaufrufe oder Oberfl\xE4che.",
+    title: "Counter",
+    description: "Collects incoming texts without model calls or interface.",
     backend: "src/server.ts"
   },
   files: {
@@ -703,13 +703,13 @@ export const contract = {
   state,
   functions: {
     record: {
-      label: "Text z\xE4hlen",
+      label: "Count text",
       input: Type.Object({ text: Type.String() }, { additionalProperties: false }),
       output: Type.Object({ count: Type.Integer(), texts: Type.Array(Type.String()) }, { additionalProperties: false }),
       tool: { name: "record_text" },
     },
     inspect: {
-      label: "Z\xE4hler lesen",
+      label: "Read counter",
       input: Type.Object({}, { additionalProperties: false }),
       output: state,
       tool: { name: "read_counter" },
@@ -748,25 +748,25 @@ import { createTestContext } from "@ragents/server/testing";
 import { contract } from "../src/contract.ts";
 import program from "../src/server.ts";
 
-test("Eingaben und Funktionen teilen denselben Z\xE4hler", async () => {
+test("inputs and functions share the same counter", async () => {
   const context = createTestContext<Static<typeof contract.state>>({ state: {} });
-  for (const content of ["eins", "zwei", "drei"]) {
+  for (const content of ["one", "two", "three"]) {
     await program.onInput!({ id: content, content, artifactIds: [], sourceEventIds: [], subscriptionId: null, event: null }, context);
   }
-  assert.deepEqual(await program.functions.inspect({}, context), { texts: ["eins", "zwei", "drei"], count: 3 });
-  assert.deepEqual(await program.functions.record({ text: "vier" }, context), { texts: ["eins", "zwei", "drei", "vier"], count: 4 });
-  assert.deepEqual(context.state.read(), { texts: ["eins", "zwei", "drei", "vier"], count: 4 });
+  assert.deepEqual(await program.functions.inspect({}, context), { texts: ["one", "two", "three"], count: 3 });
+  assert.deepEqual(await program.functions.record({ text: "four" }, context), { texts: ["one", "two", "three", "four"], count: 4 });
+  assert.deepEqual(context.state.read(), { texts: ["one", "two", "three", "four"], count: 4 });
 });
 `
   }
 };
 var sharedList = {
   id: "shared-list",
-  title: "Gemeinsame Liste eines Actors",
-  description: "Ein Actor besitzt eine Funktion und eine React-View f\xFCr denselben Listenstand.",
+  title: "Shared list of an actor",
+  description: "An actor owns a function and a React view for the same list state.",
   ragents: {
-    title: "Gemeinsame Liste",
-    description: "Sammelt Texte aus der App und aus einem Agenten-Werkzeug in einer gemeinsamen Liste.",
+    title: "Shared list",
+    description: "Collects texts from the app and from an agent tool in a shared list.",
     backend: "src/server.ts",
     views: [{ id: "main", client: "src/client.tsx" }]
   },
@@ -781,21 +781,21 @@ type FormValues = Parameters<typeof UI.Form>[0]["values"];
 const App = () => {
   const state = useAppState();
   const [values, setValues] = React.useState<FormValues>({ text: "" });
-  const [status, setStatus] = React.useState("Bereit");
+  const [status, setStatus] = React.useState("Ready");
   const entries = state.entries ?? [];
 
   const append = async (next: FormValues): Promise<void> => {
     const answer = await context.capabilities.call("append", { text: String(next.text ?? "") });
     setValues({ text: "" });
-    setStatus(\`Hinzugef\xFCgt: \${answer.text}\`);
+    setStatus(\`Added: \${answer.text}\`);
   };
 
   return (
-    <UI.AppLayout title="Gemeinsame Liste" description={<>{entries.length} {entries.length === 1 ? "Eintrag" : "Eintr\xE4ge"}</>}>
+    <UI.AppLayout title="Shared list" description={<>{entries.length} {entries.length === 1 ? "item" : "items"}</>}>
       <UI.Grid>
         <UI.Form fields={[
-          { id: "text", label: "Neuer Eintrag", type: "textarea", placeholder: "Text eingeben" },
-        ]} values={values} onChange={setValues} onSubmit={append} submitLabel="Hinzuf\xFCgen" />
+          { id: "text", label: "New item", type: "textarea", placeholder: "Enter text" },
+        ]} values={values} onChange={setValues} onSubmit={append} submitLabel="Add" />
         <UI.Stack>
           <p className="text-muted-foreground" role="status">{status}</p>
           <ul className="border-t border-border">
@@ -808,7 +808,7 @@ const App = () => {
 };
 
 const root = document.getElementById("root");
-if (!root) throw new Error("Das Wurzelelement #root fehlt.");
+if (!root) throw new Error("The #root element is missing.");
 createRoot(root).render(<App />);
 `,
     "src/contract.ts": `import { Type } from "typebox";
@@ -817,9 +817,9 @@ export const contract = {
   state: Type.Object({ entries: Type.Optional(Type.Array(Type.String())) }, {"additionalProperties": false}),
   functions: {
     append: {
-      label: "Eintrag hinzuf\xFCgen",
-      description: "H\xE4ngt den eingegebenen Text an die gemeinsame Liste an.",
-      input: Type.Object({ text: Type.String({"description": "Der Text f\xFCr den neuen Listeneintrag."}) }, {"additionalProperties": false}),
+      label: "Add entry",
+      description: "Appends the entered text to the shared list.",
+      input: Type.Object({ text: Type.String({"description": "The text for the new list entry."}) }, {"additionalProperties": false}),
       output: Type.Object({ text: Type.String(), entries: Type.Array(Type.String()) }, {"additionalProperties": false}),
       capabilities: [],
       tool: { name: "append_to_list", card: true },
@@ -849,11 +849,11 @@ import { createTestContext } from "@ragents/server/testing";
 import { contract } from "../src/contract.ts";
 import program from "../src/server.ts";
 
-test("erg\xE4nzt Eintr\xE4ge ohne vorhandene Eintr\xE4ge zu verlieren", async () => {
+test("adds entries without losing existing entries", async () => {
   const context = createTestContext<Static<typeof contract.state>>({ state: {} });
-  assert.deepEqual(await program.functions.append({"text": "  Erster Eintrag  "}, context), {"text": "Erster Eintrag", "entries": ["Erster Eintrag"]});
-  assert.deepEqual(await program.functions.append({"text": "Zweiter Eintrag"}, context), {"text": "Zweiter Eintrag", "entries": ["Erster Eintrag", "Zweiter Eintrag"]});
-  assert.deepEqual(context.state.read(), {"entries": ["Erster Eintrag", "Zweiter Eintrag"]});
+  assert.deepEqual(await program.functions.append({"text": "  First entry  "}, context), {"text": "First entry", "entries": ["First entry"]});
+  assert.deepEqual(await program.functions.append({"text": "Second entry"}, context), {"text": "Second entry", "entries": ["First entry", "Second entry"]});
+  assert.deepEqual(context.state.read(), {"entries": ["First entry", "Second entry"]});
 });
 `
   }
@@ -866,7 +866,7 @@ var templateFiles = (template, name2) => ({
 });
 var templateById = (id) => {
   const template = runModuleTemplates.find((candidate) => candidate.id === id);
-  if (!template) throw new Error(`Unbekannte Actor-Programm-Vorlage ${id}. G\xFCltig: ${runModuleTemplates.map((entry) => entry.id).join(", ")}.`);
+  if (!template) throw new Error(`Unknown actor program template ${id}. Valid: ${runModuleTemplates.map((entry) => entry.id).join(", ")}.`);
   return template;
 };
 
@@ -934,7 +934,7 @@ var createTestReport = async (directory) => {
   const describe = (failure) => {
     const fileOutput = failure.message === "test failed" && failure.file !== null ? stderrByFile.get(failure.file) ?? stderrByFile.get(relative(failure.file)) : void 0;
     const message = fileOutput ? errorLines(fileOutput).join("; ") : failure.generated ? failure.message.split("\n")[0].replace(/:$/, "") : failure.message.trim().slice(0, 500);
-    const values = failure.expected === void 0 || failure.expected === failure.actual ? "" : ` - erwartet ${failure.expected}, tats\xE4chlich ${failure.actual}`;
+    const values = failure.expected === void 0 || failure.expected === failure.actual ? "" : ` - expected ${failure.expected}, actual ${failure.actual}`;
     return `- ${failure.name} (${placeOf(failure)}): ${relative(message)}${relative(values)}`;
   };
   return {
@@ -946,10 +946,10 @@ var createTestReport = async (directory) => {
     report: (name2, outcome) => {
       record2(pending);
       pending = "";
-      const summary = outcome.timedOut ? `Tests f\xFCr ${name2} nach Zeit\xFCberschreitung abgebrochen: ${passed} bestanden, ${failed2} fehlgeschlagen.` : `Tests f\xFCr ${name2} fehlgeschlagen: ${passed} bestanden, ${failed2} fehlgeschlagen.`;
+      const summary = outcome.timedOut ? `Tests for ${name2} canceled after a timeout: ${passed} passed, ${failed2} failed.` : `Tests for ${name2} failed: ${passed} passed, ${failed2} failed.`;
       const details = failures.map(describe);
-      const more = failed2 > failures.length ? [`... und ${failed2 - failures.length} weitere`] : [];
-      const withoutResult = failed2 === 0 ? [`Der Testlauf endete${outcome.code === null ? "" : ` mit Code ${outcome.code}`} ohne fehlgeschlagenen Test:`, ...errorLines([...unparsed, ...outcome.stderr.split("\n")]).map(relative)] : [];
+      const more = failed2 > failures.length ? [`... and ${failed2 - failures.length} more`] : [];
+      const withoutResult = failed2 === 0 ? [`The test run ended${outcome.code === null ? "" : ` with code ${outcome.code}`} without a failed test:`, ...errorLines([...unparsed, ...outcome.stderr.split("\n")]).map(relative)] : [];
       return [summary, ...details, ...more, ...withoutResult].join("\n");
     }
   };
@@ -969,16 +969,16 @@ var checkFailure = (title, lines, fallback) => {
   const shown = all.slice(0, maxShownComplaints).map((line) => line.length > maxComplaintLength ? `${line.slice(0, maxComplaintLength - 3)}...` : line);
   const omitted = all.length - shown.length;
   return Object.assign(new Error([
-    `${title}: ${all.length} Fehler.`,
+    `${title}: ${all.length} errors.`,
     ...shown,
-    ...omitted > 0 ? [`... und ${omitted} weitere; alle mit actor_program_diagnostics.`] : []
+    ...omitted > 0 ? [`... and ${omitted} more; all with actor_program_diagnostics.`] : []
   ].join("\n")), { lines: all });
 };
 var actorDescriptionOf = (text) => {
   const line = (text ?? "").replace(/\s+/g, " ").trim();
   return line.length <= actorDescriptionMaxLength ? line || void 0 : `${line.slice(0, actorDescriptionMaxLength - 3).trimEnd()}...`;
 };
-var exposed = defineToolAvailability({ availability: "conditional", availabilityDetail: "Ver\xF6ffentlichte Funktion eines aktiven Actors im Run." }, () => true);
+var exposed = defineToolAvailability({ availability: "conditional", availabilityDetail: "Published function of an active actor in the run." }, () => true);
 var objectSchema = { type: "object", additionalProperties: true };
 var checked = (schema, value, label) => {
   const result = jsonValue(value, label);
@@ -988,17 +988,17 @@ var checked = (schema, value, label) => {
 };
 var safePath = (name2) => {
   if (!name2 || path.isAbsolute(name2) || name2.includes("\\") || name2.includes("\0") || name2.split("/").some((part) => !part || part === "." || part === ".."))
-    throw new Error(`Ung\xFCltiger Paketpfad ${name2}.`);
+    throw new Error(`Invalid package path ${name2}.`);
   return name2;
 };
 var inside = async (directory, relative) => {
   const root = await realpath2(directory);
   const file = await realpath2(path.join(root, safePath(relative)));
   if (!file.startsWith(`${root}${path.sep}`))
-    throw new Error(`Paketpfad ${relative} liegt au\xDFerhalb des Pakets.`);
+    throw new Error(`Package path ${relative} is outside the package.`);
   const stat = await lstat(file);
   if (!stat.isFile() || stat.size > 2e6)
-    throw new Error(`Ung\xFCltige oder zu gro\xDFe Paketdatei ${relative}.`);
+    throw new Error(`Invalid or too large package file ${relative}.`);
   return readFile(file, "utf8");
 };
 var occupied = (file) => {
@@ -1011,7 +1011,7 @@ var occupied = (file) => {
     throw error;
   }
 };
-var packageExists = (name2) => new Error(`Das Paket ${name2} existiert bereits.`);
+var packageExists = (name2) => new Error(`The package ${name2} already exists.`);
 var commitPackage = (staged, directory, name2) => {
   if (occupied(directory))
     throw packageExists(name2);
@@ -1067,16 +1067,16 @@ var ActorProgramRuntime = class {
   actor(runId, actorId) {
     const actor = this.view(runId).actors.find((candidate) => candidate.id === actorId);
     if (!actor || actor.kind === "human" || actor.lifecycle.kind === "stopped")
-      throw new Error("Der Actor ist nicht aktiv.");
+      throw new Error("The actor is not active.");
     if (this.#removing.has(`${runId}\0${actorId}`))
-      throw new Error("Das Actor-Paket wird entfernt.");
+      throw new Error("The actor package is being removed.");
     return actor;
   }
   resolveActor(runId, callerId, reference) {
     const actors = this.view(runId).actors;
     const found = reference === "self" ? actors.find((candidate) => candidate.id === callerId) : actorByHandle(actors, reference);
     if (!found)
-      throw new Error(`Actor ${reference} ist unbekannt.`);
+      throw new Error(`Actor ${reference} is unknown.`);
     return this.actor(runId, found.id);
   }
   data(runId, actorId) {
@@ -1086,7 +1086,7 @@ var ActorProgramRuntime = class {
     return { version: 1, revision, values: entry?.state ?? {} };
   }
   #writeProgram(context, runId, actorId, program) {
-    this.runtime().replacePluginState(this.operatorContext(runId), runId, { pluginId: ACTOR_PROGRAMS_STATE_ID, scope: { kind: "actor", actorId }, state: jsonValue({ version: 1, program }, "Actor-Programm") });
+    this.runtime().replacePluginState(this.operatorContext(runId), runId, { pluginId: ACTOR_PROGRAMS_STATE_ID, scope: { kind: "actor", actorId }, state: jsonValue({ version: 1, program }, "Actor program") });
   }
   #script(runId) {
     return this.view(runId).pluginStates.find((entry) => entry.pluginId === ACTOR_SCRIPT_STATE_ID && entry.scope.kind === "run")?.state;
@@ -1095,7 +1095,7 @@ var ActorProgramRuntime = class {
     for (const source of files) {
       const file = path.join(directory, safePath(source.path));
       if (source.path.split("/").includes("node_modules"))
-        throw new Error("Paketquellen d\xFCrfen keine Abh\xE4ngigkeiten \xFCberschreiben.");
+        throw new Error("Package sources must not overwrite dependencies.");
       await mkdir(path.dirname(file), { recursive: true });
       await writeFile(file, source.content, { flag: "wx" });
     }
@@ -1113,14 +1113,14 @@ var ActorProgramRuntime = class {
     try {
       await this.#activate(this.operatorContext(runId, "refresh"), runId, program.name, false, signal);
     } catch (error) {
-      throw new Error(`Der Capability-Vertrag von ${program.name} hat sich ge\xE4ndert und die Neuaktivierung scheiterte: ${errorText(error)}`);
+      throw new Error(`The capability contract of ${program.name} has changed and the reactivation failed: ${errorText(error)}`);
     }
   }
   async #bound(runId, actorId, revision, signal, contractOf, descriptorsFor) {
     const current = () => {
       const program2 = this.programs(runId).find((entry) => entry.actorId === actorId);
       if (!program2)
-        throw new Error("Der Actor besitzt kein aktives Programm.");
+        throw new Error("The actor has no active program.");
       return program2;
     };
     const bind = (program2) => {
@@ -1130,14 +1130,14 @@ var ActorProgramRuntime = class {
     };
     const program = current();
     if (revision !== void 0 && program.revision !== revision)
-      throw new Error("Das Actor-Paket wurde ersetzt.");
+      throw new Error("The actor package was replaced.");
     const bound = bind(program);
     if (!bound.drifted)
       return bound;
     await this.#refresh(runId, program, signal);
     const refreshed = bind(current());
     if (refreshed.drifted)
-      throw new Error(`Der Capability-Vertrag von ${program.name} weicht auch nach der Neuaktivierung ab.`);
+      throw new Error(`The capability contract of ${program.name} still differs after the reactivation.`);
     return refreshed;
   }
   async workspaceDirectory(runId) {
@@ -1153,7 +1153,7 @@ var ActorProgramRuntime = class {
     const directory = path.join(actors, name2);
     const key = `${runId}\0${name2}`;
     if (this.#creating.has(key))
-      throw new Error(`Das Paket ${name2} wird gerade angelegt.`);
+      throw new Error(`The package ${name2} is being created.`);
     if (occupied(directory))
       throw packageExists(name2);
     this.#creating.add(key);
@@ -1204,16 +1204,16 @@ var ActorProgramRuntime = class {
     this.#assertName(name2);
     const directory = path.join(await this.workspaceDirectory(runId), name2);
     if ((await lstat(directory)).isSymbolicLink())
-      throw new Error("Actor-Pakete d\xFCrfen keine Symlinks sein.");
+      throw new Error("Actor packages must not be symlinks.");
     await prepareAppProject(directory);
     const pkg = await readAppPackage(directory);
     const previous = this.programs(runId).find((program) => program.name === name2);
     const owner = reference ? this.resolveActor(runId, callerId, reference) : previous ? this.actor(runId, previous.actorId) : !pkg.backend ? this.actor(runId, callerId) : void 0;
     if (previous && owner?.id !== previous.actorId)
-      throw new Error("Ein aktiviertes Paket kann nicht zu einem anderen Actor wechseln.");
+      throw new Error("An activated package cannot move to another actor.");
     const caller = this.view(runId).actors.find((candidate) => candidate.id === callerId);
     if (!caller)
-      throw new Error("Aufrufender Actor fehlt.");
+      throw new Error("Calling actor is missing.");
     const provisional = owner ?? {
       id: "pending",
       handle: name2,
@@ -1237,23 +1237,23 @@ var ActorProgramRuntime = class {
     const backend = pkg.backend ? await compileAppBackend({ directory, backend: pkg.backend, runId, executor: this.runtime().nativeTypeScriptExecutor, signal }) : void 0;
     const contract = backend?.contract ?? { state: objectSchema, functions: {} };
     if (contract.input && owner?.kind === "agent")
-      throw new Error("Ein LLM-Actor verarbeitet Eingaben mit seinem Agententreiber; onInput ist nur f\xFCr TypeScript-Actors erlaubt.");
+      throw new Error("An LLM actor processes inputs with its agent driver; onInput is only allowed for TypeScript actors.");
     if (contract.state.type !== "object")
-      throw new Error("Actor-Zustand muss ein Object-Schema sein.");
+      throw new Error("Actor state must be an object schema.");
     const state = owner ? this.data(runId, owner.id).values : {};
-    checked(contract.state, state, "Actor-Zustand");
+    checked(contract.state, state, "Actor state");
     const actorId = owner?.id ?? "pending";
     const actorHandle = owner?.handle ?? name2;
     const functions = Object.entries(contract.functions).map(([id, fn]) => {
       if (!/^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/.test(id))
-        throw new Error(`Ung\xFCltiger Funktionsname ${id}.`);
+        throw new Error(`Invalid function name ${id}.`);
       if (fn.tool && !/^[a-z][a-z0-9_]{0,63}$/.test(fn.tool.name))
-        throw new Error(`Ung\xFCltiger Werkzeugname ${fn.tool.name}.`);
+        throw new Error(`Invalid tool name ${fn.tool.name}.`);
       const capabilities = fn.capabilities ?? [];
       const selected2 = capabilities.map((name3) => {
         const entry = available2.find((item) => item.id === name3);
         if (!entry)
-          throw new Error(`Capability ${name3} ist nicht verf\xFCgbar.`);
+          throw new Error(`Capability ${name3} is not available.`);
         return entry;
       });
       return {
@@ -1272,27 +1272,27 @@ var ActorProgramRuntime = class {
     const inputDescriptors = inputCapabilities.map((id) => {
       const found = available2.find((entry) => entry.id === id);
       if (!found)
-        throw new Error(`Eingabe-Capability ${id} ist nicht verf\xFCgbar.`);
+        throw new Error(`Input capability ${id} is not available.`);
       return found;
     });
     await installClientSdk(directory, { stateSchema: contract.state, actions: functions.map((fn) => ({ id: fn.id, inputSchema: fn.inputSchema, resultSchema: fn.resultSchema })) });
     const hasServerFiles = pkg.backend || (await projectSourceFiles(directory)).some((file) => /^tests\/.*\.tsx?$/.test(file.path));
     const serverErrors = hasServerFiles ? typecheckServerProject(directory, pkg.backend) : [];
     if (serverErrors.length)
-      throw checkFailure(`Typpr\xFCfung von ${name2}`, serverErrors, `Die Typpr\xFCfung von ${name2} schlug ohne Meldung fehl.`);
+      throw checkFailure(`Typecheck of ${name2}`, serverErrors, `The typecheck of ${name2} failed without a message.`);
     const clients = [];
     const views = [];
     for (const view of pkg.views ?? []) {
       const client = await compileClientProject({ directory, entryPoint: view.client, stateSchema: contract.state, actions: functions.map((fn) => ({ id: fn.id, inputSchema: fn.inputSchema, resultSchema: fn.resultSchema })) });
       if (!client.valid)
         throw checkFailure(
-          `Client-Build von ${view.client}`,
+          `Client build of ${view.client}`,
           client.diagnostics.filter((item) => item.category === "error").map((item) => `${item.fileName ?? view.client}${item.start ? `:${item.start.line}:${item.start.column}` : ""} ${item.message.replace(/\s*\n\s*/g, " ")}`),
-          `Der Client-Build von ${view.client} schlug ohne Meldung fehl.`
+          `The client build of ${view.client} failed without a message.`
         );
       const styles = view.styles ? await inside(directory, view.styles) : "";
       if (/@import\b|url\s*\(\s*["']?\s*(?:https?:|\/\/)/i.test(styles))
-        throw new Error("Ansichts-CSS darf keine externen Ressourcen laden.");
+        throw new Error("View CSS must not load external resources.");
       const clientFile = `view-${view.id}.mjs`;
       clients.push({ file: clientFile, javaScript: client.javaScript });
       views.push({
@@ -1335,7 +1335,7 @@ var ActorProgramRuntime = class {
   async #activate(context, runId, name2, idle, signal, reference) {
     const key = `${runId}\0${name2}`;
     if (this.#installing.has(key))
-      throw new Error(`Paket ${name2} wird bereits aktiviert.`);
+      throw new Error(`Package ${name2} is already being activated.`);
     const epoch = this.invocationPermit(runId);
     this.#installing.add(key);
     const original = this.programs(runId).find((item) => item.name === name2);
@@ -1369,23 +1369,23 @@ var ActorProgramRuntime = class {
           throw new Error(report.report(name2, { code: result.code, timedOut: result.timedOut, stderr }));
       }
       if (canonicalHash(compiled.files) !== canonicalHash(await projectSourceFiles(compiled.directory)))
-        throw new Error("Paketdateien wurden w\xE4hrend der Pr\xFCfung ge\xE4ndert; erneut aktivieren.");
+        throw new Error("Package files were changed during the check; activate again.");
       if (epoch !== this.invocationPermit(runId))
-        throw new Error("Der Run wurde w\xE4hrend der Aktivierung gestoppt.");
+        throw new Error("The run was stopped during the activation.");
       if (this.programs(runId).find((item) => item.name === name2)?.revision !== original?.revision)
-        throw new Error("Das Paket wurde zwischenzeitlich ge\xE4ndert.");
+        throw new Error("The package was changed in the meantime.");
       if (idle)
         this.#assertIdle(runId, definition.actorId);
       const names = /* @__PURE__ */ new Set([...agentTools.map((tool) => tool.name), ...this.#options.reservedToolNames(), ...this.programs(runId).filter((program) => program.name !== name2).flatMap((program) => program.functions.flatMap((fn) => fn.tool ? [fn.tool.name] : []))]);
       for (const fn of definition.functions)
         if (fn.tool) {
           if (names.has(fn.tool.name))
-            throw new Error(`Werkzeugname ${fn.tool.name} ist bereits vergeben.`);
+            throw new Error(`Tool name ${fn.tool.name} is already taken.`);
           names.add(fn.tool.name);
         }
       const occupied2 = this.programs(runId).find((program) => program.actorId === definition.actorId && program.name !== name2);
       if (occupied2)
-        throw new Error(`Actor @${definition.actorHandle} besitzt bereits das Paket ${occupied2.name}. Erg\xE4nze darin Funktionen oder Ansichten.`);
+        throw new Error(`Actor @${definition.actorHandle} already owns the package ${occupied2.name}. Add functions or views there.`);
       await mkdir(definition.directory, { recursive: true });
       for (const source of compiled.files) {
         const file = path.join(definition.directory, safePath(source.path));
@@ -1402,34 +1402,34 @@ var ActorProgramRuntime = class {
       await syncWorkspaceOwnership(definition.directory, await this.#options.serverProcessContextFor(runId));
       signal?.throwIfAborted();
       if (epoch !== this.invocationPermit(runId))
-        throw new Error("Der Run wurde w\xE4hrend der Aktivierung gestoppt.");
+        throw new Error("The run was stopped during the activation.");
       if (this.programs(runId).find((item) => item.name === name2)?.revision !== original?.revision)
-        throw new Error("Das Paket wurde zwischenzeitlich ge\xE4ndert.");
+        throw new Error("The package was changed in the meantime.");
       if (!compiled.createActor) {
         this.actor(runId, definition.actorId);
         if (idle)
           this.#assertIdle(runId, definition.actorId);
-        checked(definition.stateSchema, this.data(runId, definition.actorId).values, "Actor-Zustand");
+        checked(definition.stateSchema, this.data(runId, definition.actorId).values, "Actor state");
         if (this.programs(runId).some((item) => item.actorId === definition.actorId && item.name !== name2))
-          throw new Error("Der Actor besitzt inzwischen ein anderes Paket.");
+          throw new Error("The actor now owns another package.");
       }
       const currentNames = /* @__PURE__ */ new Set([...agentTools.map((tool) => tool.name), ...this.#options.reservedToolNames(), ...this.programs(runId).filter((program) => program.name !== name2).flatMap((program) => program.functions.flatMap((fn) => fn.tool ? [fn.tool.name] : []))]);
       for (const fn of definition.functions)
         if (fn.tool) {
           if (currentNames.has(fn.tool.name))
-            throw new Error(`Werkzeugname ${fn.tool.name} ist inzwischen vergeben.`);
+            throw new Error(`Tool name ${fn.tool.name} has been taken in the meantime.`);
           currentNames.add(fn.tool.name);
         }
-      jsonValue({ version: 1, program: definition }, "Actor-Programm");
+      jsonValue({ version: 1, program: definition }, "Actor program");
       if (compiled.createActor) {
         const actors = this.view(runId).actors;
         const caller = actors.find((actor2) => actor2.id === context.actorId);
         const holder = actors.find((actor2) => actor2.handle === name2);
         if (holder?.kind === "script" && holder.lifecycle.kind === "stopped") {
-          checked(definition.stateSchema, this.data(runId, holder.id).values, "Actor-Zustand");
-          this.runtime().restartActor(context, runId, holder.id, "Actor-Paket erneut aktiviert");
+          checked(definition.stateSchema, this.data(runId, holder.id).values, "Actor state");
+          this.runtime().restartActor(context, runId, holder.id, "Actor package activated again");
         } else if (holder)
-          throw new Error(`Handle @${name2} geh\xF6rt bereits dem ${holder.kind !== "human" && holder.lifecycle.kind === "stopped" ? "gestoppten" : "aktiven"} Actor ${holder.displayName}; nur ein gestoppter TypeScript-Actor wird beim Aktivieren neu gestartet. W\xE4hle einen anderen Paketnamen.`);
+          throw new Error(`Handle @${name2} already belongs to the ${holder.kind !== "human" && holder.lifecycle.kind === "stopped" ? "stopped" : "active"} actor ${holder.displayName}; only a stopped TypeScript actor is restarted on activation. Choose another package name.`);
         else
           this.runtime().createScriptActor(context, runId, { handle: name2, displayName: definition.title, description: actorDescriptionOf(definition.description), grants: caller.grants.filter((grant) => grant.delegable), toolNames: null });
         const actor = this.resolveActor(runId, context.actorId, `@${name2}`);
@@ -1461,7 +1461,7 @@ var ActorProgramRuntime = class {
     const program = this.#program(runId, name2);
     this.#assertIdle(runId, program.actorId);
     if (this.#installing.has(`${runId}\0${name2}`))
-      throw new Error("Das Paket wird gerade aktiviert.");
+      throw new Error("The package is being activated.");
     const actor = this.actor(runId, program.actorId);
     const key = `${runId}\0${program.actorId}`;
     this.#removing.add(key);
@@ -1469,7 +1469,7 @@ var ActorProgramRuntime = class {
       await this.stopActor(runId, program.actorId);
       this.#writeProgram(context, runId, program.actorId, null);
       if (actor.kind === "script")
-        this.runtime().stopActor(context, runId, program.actorId, "Actor-Paket entfernt");
+        this.runtime().stopActor(context, runId, program.actorId, "Actor package removed");
       await rm(program.directory, { recursive: true, force: true });
     } finally {
       this.#removing.delete(key);
@@ -1523,9 +1523,9 @@ var ActorProgramRuntime = class {
     const program = this.#program(runId, viewId);
     const view = program.views.find((item) => item.id === viewId);
     if (!view || program.revision !== revision)
-      throw new Error("Die Ansicht wurde ersetzt oder entfernt.");
+      throw new Error("The view was replaced or removed.");
     if (!program.stylesFile)
-      throw new Error("Das Programm stammt aus einer \xE4lteren Aktivierung ohne Stylesheet-Datei. Bitte erneut aktivieren.");
+      throw new Error("The program comes from an older activation without a stylesheet file. Please activate again.");
     const frameStyles = readFileSync(path.join(program.directory, program.stylesFile), "utf8");
     return { ...view, styles: `${frameStyles}
 ${view.styles}`, platformVersion: 2, clientJavaScript: readFileSync(path.join(program.directory, view.clientFile), "utf8") };
@@ -1552,7 +1552,7 @@ ${view.styles}`, platformVersion: 2, clientJavaScript: readFileSync(path.join(pr
     const operation = previous.then(() => {
       signal.throwIfAborted();
       if (permit !== this.invocationPermit(runId))
-        throw new Error("Der Run wurde vor dem Funktionsstart gestoppt.");
+        throw new Error("The run was stopped before the function started.");
       this.actor(runId, actorId);
       return execute();
     });
@@ -1567,10 +1567,10 @@ ${view.styles}`, platformVersion: 2, clientJavaScript: readFileSync(path.join(pr
   }
   async #backend(runId, program, input, binding, descriptors, signal) {
     if (!program.backendFile)
-      throw new Error("Der Actor besitzt kein TypeScript-Backend.");
+      throw new Error("The actor has no TypeScript backend.");
     const current = this.#program(runId, program.name);
     if (current.revision !== program.revision)
-      throw new Error("Das Actor-Paket wurde ersetzt.");
+      throw new Error("The actor package was replaced.");
     const logs = [];
     let calls = 0;
     const initial = this.data(runId, program.actorId);
@@ -1588,39 +1588,39 @@ ${view.styles}`, platformVersion: 2, clientJavaScript: readFileSync(path.join(pr
     }, call: async (name2, value) => {
       const capability = descriptors.find((entry) => entry.id === name2);
       if (!capability)
-        throw new Error(`Capability ${name2} ist nicht deklariert.`);
+        throw new Error(`Capability ${name2} is not declared.`);
       if (++calls > 64)
-        throw new Error("Ein Aufruf darf h\xF6chstens 64 Capabilities ausf\xFChren.");
+        throw new Error("A call may run at most 64 capabilities.");
       if (program.functions.some((fn) => fn.tool?.name === name2))
-        throw new Error("Eine Actor-Funktion darf sich nicht \xFCber ein Werkzeug selbst aufrufen; verwende eine gemeinsame TypeScript-Funktion.");
-      checked(capability.schema, value, `Eingabe ${name2}`);
+        throw new Error("An actor function must not call itself through a tool; use a shared TypeScript function.");
+      checked(capability.schema, value, `Input ${name2}`);
       const output = await binding.call(name2, value, calls);
-      return checked(capability.resultSchema, output, `Ergebnis ${name2}`);
+      return checked(capability.resultSchema, output, `Result ${name2}`);
     } });
     signal.throwIfAborted();
     this.actor(runId, program.actorId);
-    const state = checked(program.stateSchema, result.state, "Actor-Zustand");
+    const state = checked(program.stateSchema, result.state, "Actor state");
     return { result: result.result, logs, state, initial };
   }
   #commitState(runId, actorId, state, initial) {
     if (canonicalHash(state) === canonicalHash(initial.values))
       return;
     if (this.data(runId, actorId).revision !== initial.revision)
-      throw new Error("Der Actor-Zustand wurde w\xE4hrend des Aufrufs ge\xE4ndert. Erneut aufrufen.");
+      throw new Error("The actor state was changed during the call. Call again.");
     this.runtime().replaceActorState(this.operatorContext(runId), runId, actorId, state);
   }
   #executeFunction(runId, bound, declared, input, binding, signal) {
     const functionOf = (program) => {
       const fn = program.functions.find((entry) => entry.id === declared.id);
       if (!fn)
-        throw new Error("Die Funktion ist nicht deklariert.");
+        throw new Error("The function is not declared.");
       return fn;
     };
     return this.#serial(runId, bound.actorId, signal, async () => {
       const { program, contract: fn, descriptors } = await this.#bound(runId, bound.actorId, bound.revision, signal, functionOf, binding.descriptorsFor);
-      const value = checked(fn.inputSchema, input, `Eingabe ${fn.id}`);
+      const value = checked(fn.inputSchema, input, `Input ${fn.id}`);
       const result = await this.#backend(runId, program, { kind: "function", functionId: fn.id, input: value }, binding, descriptors, signal);
-      const output = checked(fn.resultSchema, result.result, `Ergebnis ${fn.id}`);
+      const output = checked(fn.resultSchema, result.result, `Result ${fn.id}`);
       this.#commitState(runId, program.actorId, result.state, result.initial);
       binding.output?.push(...result.logs);
       return output;
@@ -1631,7 +1631,7 @@ ${view.styles}`, platformVersion: 2, clientJavaScript: readFileSync(path.join(pr
     try {
       const inputOf = (program) => {
         if (!program.input)
-          throw new Error("Dieser TypeScript-Actor besitzt keinen onInput-Handler.");
+          throw new Error("This TypeScript actor has no onInput handler.");
         return program.input;
       };
       const descriptorsFor = (capabilityIds) => agentCapabilityBinding(this.actor(request.runId, request.agentId), request.tools, capabilityIds, /* @__PURE__ */ new Set()).descriptors;
@@ -1650,44 +1650,44 @@ ${view.styles}`, platformVersion: 2, clientJavaScript: readFileSync(path.join(pr
   }
   invocationPermit(runId) {
     if (this.#shuttingDown || this.#stopping.has(runId))
-      throw new Error("Der Run wird gestoppt.");
+      throw new Error("The run is being stopped.");
     return this.#epochs.get(runId) ?? 0;
   }
   startInvocation(runId, viewId, revision, functionId, requestId, input, permit = this.invocationPermit(runId)) {
     const program = this.#program(runId, viewId);
     if (!program.views.some((view) => view.id === viewId))
-      throw new Error("Die Ansicht ist unbekannt.");
+      throw new Error("The view is unknown.");
     return this.#start(runId, program, viewId, revision, functionId, requestId, input, permit);
   }
   startFunctionInvocation(runId, actorHandle, revision, functionId, requestId, input, permit = this.invocationPermit(runId)) {
     const program = this.programs(runId).find((entry) => entry.actorHandle === handleKey(actorHandle));
     if (!program)
-      throw new Error("Der Actor ver\xF6ffentlicht kein Programm.");
+      throw new Error("The actor publishes no program.");
     return this.#start(runId, program, program.name, revision, functionId, requestId, input, permit);
   }
   #start(runId, program, viewId, revision, functionId, requestId, input, permit) {
     this.#knownRuns.add(runId);
     if (permit !== this.invocationPermit(runId))
-      throw new Error("Der Run wurde inzwischen gestoppt.");
+      throw new Error("The run has been stopped in the meantime.");
     if (program.revision !== revision)
-      throw new Error("Das Actor-Paket wurde ersetzt. Ansicht aktualisieren.");
+      throw new Error("The actor package was replaced. Refresh the view.");
     const fn = program.functions.find((entry) => entry.id === functionId);
     if (!fn)
-      throw new Error("Die Funktion ist nicht deklariert.");
+      throw new Error("The function is not declared.");
     const state = this.#invocations(runId);
     const prior = state.invocations.find((entry) => entry.requestId === requestId);
     if (prior) {
       if (prior.actorId !== program.actorId || prior.actionId !== functionId || prior.revision !== revision || canonicalHash(prior.input) !== canonicalHash(input))
-        throw new Error("Die Request-ID wurde bereits f\xFCr einen anderen Aufruf verwendet.");
+        throw new Error("The request ID was already used for another call.");
       return prior;
     }
     if (!requestId || requestId.length > 200 || state.requestIds.includes(requestId))
-      throw new Error("Ung\xFCltige oder bereits verarbeitete Request-ID.");
+      throw new Error("Invalid or already processed request ID.");
     if (state.requestIds.length >= 1e4)
-      throw new Error("Der Run hat seine Aufrufgrenze erreicht.");
+      throw new Error("The run has reached its call limit.");
     if ([...this.#active.values()].filter((entry) => entry.runId === runId).length >= 8)
-      throw new Error("Es laufen bereits acht Actor-Funktionen.");
-    checked(fn.inputSchema, input, "Funktionseingabe");
+      throw new Error("Eight actor functions are already running.");
+    checked(fn.inputSchema, input, "Function input");
     const invocation = { id: randomUUID(), requestId, actorId: program.actorId, actorHandle: program.actorHandle, appId: viewId, revision, actionId: functionId, input, output: [], createdAt: (/* @__PURE__ */ new Date()).toISOString(), status: "queued" };
     this.#replaceInvocation(runId, invocation, true);
     const controller = new AbortController();
@@ -1696,15 +1696,15 @@ ${view.styles}`, platformVersion: 2, clientJavaScript: readFileSync(path.join(pr
       this.#replaceInvocation(runId, started);
       try {
         if (fn.confirmation && !await this.#confirm(runId, invocation, fn.confirmation, controller.signal))
-          throw new Error("Die Funktion wurde nicht best\xE4tigt.");
+          throw new Error("The function was not confirmed.");
         const descriptorsFor = (capabilityIds) => operatorCapabilityBinding(this.ownerId(runId), this.#options.operations.list(), capabilityIds).descriptors;
         const output = [];
         const result = await this.#executeFunction(runId, program, fn, input, { output, id: invocation.id, kind: "app-action", principal: { id: this.ownerId(runId), kind: "operator" }, descriptorsFor, call: async (name2, value, index) => {
           const operation = this.#options.operations.operation(name2);
           const id = `${invocation.id}:capability:${index}`;
-          const confirmation = operation.operator === "confirm" ? await this.#confirm(runId, invocation, `${operation.label} ausf\xFChren?`, controller.signal, value) : true;
+          const confirmation = operation.operator === "confirm" ? await this.#confirm(runId, invocation, `Run ${operation.label}?`, controller.signal, value) : true;
           if (!confirmation)
-            throw new Error("Die Aktion wurde nicht best\xE4tigt.");
+            throw new Error("The action was not confirmed.");
           return this.#options.operations.invoke(name2, { runId, invocationId: id, principal: { kind: "operator", actorId: this.ownerId(runId) }, signal: controller.signal, ...operation.operator === "confirm" ? { operatorConfirmation: { operationId: name2, invocationId: id, inputHash: canonicalHash(value) } } : {} }, value);
         } }, controller.signal);
         this.#replaceInvocation(runId, { ...started, status: "succeeded", result, output, finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
@@ -1718,7 +1718,7 @@ ${view.styles}`, platformVersion: 2, clientJavaScript: readFileSync(path.join(pr
   invocation(runId, reference, id) {
     const invocation = this.#invocations(runId).invocations.find((entry) => entry.id === id && (entry.appId === reference || entry.actorHandle === reference));
     if (!invocation)
-      throw new Error("Der Funktionsaufruf ist unbekannt.");
+      throw new Error("The function call is unknown.");
     return invocation;
   }
   #invocations(runId) {
@@ -1734,18 +1734,18 @@ ${view.styles}`, platformVersion: 2, clientJavaScript: readFileSync(path.join(pr
       finished.shift();
       state.invocations = [...active, ...finished];
     }
-    assertJsonValue2(state, "Actor-Aufrufe");
+    assertJsonValue2(state, "Actor calls");
     this.runtime().replacePluginState(this.operatorContext(runId), runId, { pluginId: ACTOR_INVOCATIONS_STATE_ID, scope: { kind: "run" }, state });
   }
   async #confirm(runId, invocation, question, signal, input = invocation.input) {
     const answer = await this.#options.askService().ask({ runId, agentId: this.ownerId(runId), turnId: null, commandId: `actor-confirm:${randomUUID()}` }, { question: `${question}
-Eingabe: ${JSON.stringify(input).slice(0, 500)}`, options: ["Ausf\xFChren", "Abbrechen"], multi: false, description: `Funktion ${invocation.actionId} von @${invocation.actorHandle}`, parameters: { source: ACTOR_PROGRAMS_STATE_ID, invocationId: invocation.id } }, signal);
-    return answer === "Ausf\xFChren";
+Input: ${JSON.stringify(input).slice(0, 500)}`, options: ["Run", "Cancel"], multi: false, description: `Function ${invocation.actionId} of @${invocation.actorHandle}`, parameters: { source: ACTOR_PROGRAMS_STATE_ID, invocationId: invocation.id } }, signal);
+    return answer === "Run";
   }
   #program(runId, reference) {
     const program = this.programs(runId).find((entry) => entry.name === reference || entry.views.some((view) => view.id === reference));
     if (!program)
-      throw new Error(`Actor-Paket ${reference} ist nicht aktiv.`);
+      throw new Error(`Actor package ${reference} is not active.`);
     return program;
   }
   #instance(program) {
@@ -1753,15 +1753,15 @@ Eingabe: ${JSON.stringify(input).slice(0, 500)}`, options: ["Ausf\xFChren", "Abb
   }
   #assertName(name2) {
     if (!NAME.test(name2))
-      throw new Error("Paketnamen beginnen mit einem Kleinbuchstaben und enthalten h\xF6chstens 64 Kleinbuchstaben, Ziffern oder Bindestriche.");
+      throw new Error("Package names begin with a lowercase letter and contain at most 64 lowercase letters, digits, or hyphens.");
   }
   #assertIdle(runId, actorId) {
     if (this.#queues.has(`${runId}\0${actorId}`) || [...this.#active.values()].some((entry) => entry.runId === runId && entry.actorId === actorId))
-      throw new Error("Der Actor hat noch laufende Funktionen oder Eingaben.");
+      throw new Error("The actor still has running functions or inputs.");
   }
   async stopActor(runId, actorId) {
     const active = [...this.#active.values()].filter((entry) => entry.runId === runId && entry.actorId === actorId);
-    active.forEach((entry) => entry.controller.abort(new Error("Actor gestoppt.")));
+    active.forEach((entry) => entry.controller.abort(new Error("Actor stopped.")));
     const state = this.view(runId).pluginStates.find((entry) => entry.pluginId === ACTOR_PROGRAMS_STATE_ID && entry.scope.kind === "actor" && entry.scope.actorId === actorId)?.state;
     if (state?.program)
       await this.runtime().nativeTypeScriptExecutor.stopInstance(runId, this.#instance(state.program));
@@ -1772,7 +1772,7 @@ Eingabe: ${JSON.stringify(input).slice(0, 500)}`, options: ["Ausf\xFChren", "Abb
     this.#stopping.add(runId);
     try {
       const active = [...this.#active.values()].filter((entry) => entry.runId === runId);
-      active.forEach((entry) => entry.controller.abort(new Error("Run gestoppt.")));
+      active.forEach((entry) => entry.controller.abort(new Error("Run stopped.")));
       await this.runtime().nativeTypeScriptExecutor.stopRun(runId);
       await Promise.allSettled([...active.map((entry) => entry.completed), ...[...this.#queues].filter(([key]) => key.startsWith(`${runId}\0`)).map(([, queue]) => queue)]);
     } finally {
@@ -1788,7 +1788,7 @@ Eingabe: ${JSON.stringify(input).slice(0, 500)}`, options: ["Ausf\xFChren", "Abb
       return;
     for (const invocation of this.#invocations(runId).invocations)
       if (invocation.status === "queued" || invocation.status === "running")
-        this.#replaceInvocation(runId, { ...invocation, status: "cancelled", error: "Der Server wurde w\xE4hrend des Aufrufs beendet.", finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+        this.#replaceInvocation(runId, { ...invocation, status: "cancelled", error: "The server was stopped during the call.", finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
   }
   async stopSession(runId, _signal) {
     await this.stopRun(runId);
@@ -1819,7 +1819,7 @@ var metadata = [
   { name: "actor_program_diagnostics", label: "Actor Program Diagnostics", description: "Read the last project diagnostics.", longDescription: "Changed errors are automatically supplied before the next model request." }
 ];
 var actorProgramManagementToolNames = metadata.map((entry) => entry.name);
-var actorProgramToolsAvailable = defineToolAvailability2({ availability: "conditional", availabilityDetail: "F\xFCr ausf\xFChrbare Actors mit agent.spawn und plugin.state.write." }, (actor) => actor.kind !== "human" && holdsUsable(actor, "agent.spawn") && holdsUsable(actor, "plugin.state.write"));
+var actorProgramToolsAvailable = defineToolAvailability2({ availability: "conditional", availabilityDetail: "For executable actors with agent.spawn and plugin.state.write." }, (actor) => actor.kind !== "human" && holdsUsable(actor, "agent.spawn") && holdsUsable(actor, "plugin.state.write"));
 var name = Type.String({ pattern: "^[a-z][a-z0-9-]{0,63}$" });
 var managementTools = (runtime, diagnostics) => [
   defineRunFunction2({ ...metadata[0], schema: Type.Object({ name, template: Type.Union(runtime.templates().map((entry) => Type.Literal(entry.id, { description: entry.description }))) }, { additionalProperties: false }), resultSchema: Type.Object({ name: Type.String(), directory: Type.String(), files: Type.Array(Type.String()) }, { additionalProperties: false }), available: actorProgramToolsAvailable, executionMode: "sequential", run: (scope, _id, input) => runtime.scaffold(scope.caller.runId, input.name, input.template) }),
@@ -1863,17 +1863,17 @@ var actorProgramSummary = boundToTools(
 );
 
 // server/controls-tool.ts
-var available = defineToolAvailability3({ availability: "always", availabilityDetail: "Typisierte UI-Referenz des installierten Actor-Programm-Plugins." }, () => true);
+var available = defineToolAvailability3({ availability: "always", availabilityDetail: "Typed UI reference of the installed actor program plugin." }, () => true);
 var metadata2 = {
   name: "actor_program_controls",
-  label: "Actor-Programm-Anleitung und Controls nachschlagen",
+  label: "Look up actor program guide and controls",
   description: "Read Mini-App control contracts or the actor-program authoring guide.",
   longDescription: "With topic: guide, explain the TypeScript package workflow through actor_program_activate. Otherwise list control names, or select one component (for example Form) for only its TypeScript props and supporting types. Import controls from @ragents/client/ui and use these exact props."
 };
 var describeClientControls = (component) => {
   const components = readClientUiComponentNames();
   if (component === void 0) return { components };
-  if (!components.includes(component)) throw new Error(`Unbekanntes Control ${component}. G\xFCltig: ${components.join(", ")}`);
+  if (!components.includes(component)) throw new Error(`Unknown control ${component}. Valid: ${components.join(", ")}`);
   return { files: readClientUiComponentContracts(component) };
 };
 var createControlsToolContributor = () => ({
@@ -1893,7 +1893,7 @@ var createControlsToolContributor = () => ({
     ]),
     run: async (_scope, _call, input) => {
       if (input.topic === "guide") {
-        if (input.component !== void 0) throw new Error("component ist nur bei topic: controls oder ohne topic erlaubt; f\xFCr topic: guide lasse component weg.");
+        if (input.component !== void 0) throw new Error("component is only allowed with topic: controls or without topic; for topic: guide, omit component.");
         return { guide: await actorProgramGuide.render({}) };
       }
       return describeClientControls(input.component);
@@ -1919,7 +1919,7 @@ var errorLines2 = (error) => {
   const complete = error instanceof Error ? error.lines : void 0;
   if (Array.isArray(complete) && complete.every((line) => typeof line === "string")) return [...new Set(complete)];
   const lines = messageOf(error).split("\n").map((line) => line.trim()).filter(Boolean);
-  const issues = lines.filter((line) => !/^(Build failed with \d+ errors?:|.*(?:Typprüfung|Typecheck|Diagnostik).*:)$/i.test(line));
+  const issues = lines.filter((line) => !/^(Build failed with \d+ errors?:|.*(?:Typecheck|Diagnostics).*:)$/i.test(line));
   return [...new Set(issues.length ? issues : lines)];
 };
 var allErrors = (snapshot) => Object.entries(snapshot.programs).sort(([left], [right]) => left.localeCompare(right)).flatMap(([programName, program]) => program.errors.map((error) => `${programName}: ${error}`));
@@ -1955,7 +1955,7 @@ var createProjectDiagnostics = (options) => {
           let fingerprint;
           let errors = [];
           try {
-            if (entry.isSymbolicLink()) throw new Error("Actor-Projekte d\xFCrfen keine Symlinks sein.");
+            if (entry.isSymbolicLink()) throw new Error("Actor projects must not be symlinks.");
             fingerprint = fingerprintOf(await projectSourceFiles2(path2.join(directory, entry.name)));
           } catch (error) {
             errors = errorLines2(error);
@@ -1993,13 +1993,13 @@ var createProjectDiagnostics = (options) => {
       const after = new Set(allErrors(next));
       const added = [...after].filter((error) => !before.has(error));
       const resolved = [...before].filter((error) => !after.has(error));
-      const changes = [...added.map((error) => `Neu: ${error}`), ...resolved.map((error) => `Behoben: ${error}`)];
+      const changes = [...added.map((error) => `New: ${error}`), ...resolved.map((error) => `Fixed: ${error}`)];
       const lines = changes.slice(0, maxDeltaLines).map((line) => line.length > maxLineLength ? `${line.slice(0, maxLineLength - 3)}...` : line);
       const omitted = changes.length - lines.length;
       return [
-        `Actor-Programm-Projektpr\xFCfung (TypeScript und Build): ${after.size} Fehler in ${Object.keys(next.programs).length} Projekten; ${added.length} neu, ${resolved.length} behoben.`,
+        `Actor program project check (TypeScript and build): ${after.size} errors in ${Object.keys(next.programs).length} projects; ${added.length} new, ${resolved.length} fixed.`,
         ...lines,
-        ...omitted > 0 ? [`${omitted} weitere \xC4nderungen. Vollst\xE4ndiger letzter Stand: actor_program_diagnostics.`] : []
+        ...omitted > 0 ? [`${omitted} more changes. Complete last state: actor_program_diagnostics.`] : []
       ].join("\n");
     }
   };
@@ -2007,10 +2007,10 @@ var createProjectDiagnostics = (options) => {
     contribution,
     latest(runId, actorId, programName) {
       const snapshot = snapshots.get(runId)?.get(actorId);
-      if (!snapshot) return "Noch kein Actor-Programm-Projektstand f\xFCr diesen Agenten gepr\xFCft.";
+      if (!snapshot) return "No actor program project state checked for this agent yet.";
       const programs = Object.entries(snapshot.programs).filter(([id]) => programName === void 0 || id === programName);
-      if (programs.length === 0) return programName ? `Kein gepr\xFCfter Projektstand f\xFCr ${programName}.` : "Keine Actor-Programm-Projekte vorhanden.";
-      return programs.sort(([left], [right]) => left.localeCompare(right)).map(([id, program]) => [`${id}: ${program.errors.length} Fehler`, ...program.errors].join("\n")).join("\n\n");
+      if (programs.length === 0) return programName ? `No checked project state for ${programName}.` : "No actor program projects exist.";
+      return programs.sort(([left], [right]) => left.localeCompare(right)).map(([id, program]) => [`${id}: ${program.errors.length} errors`, ...program.errors].join("\n")).join("\n\n");
     },
     forget(runId) {
       snapshots.delete(runId);