@schlenkr/ragents 0.1.10 → 0.1.12

package/plugins/ragents.reference/run-scripts/conversation-circle/src/server.ts

@@ -10,23 +10,23 @@ const contract = {
 type Start = { input: unknown };
 
 const settingsFrom = (value: unknown): { topic: string; rounds: number } => {
-  if (value === null) return { topic: "Sollten Innenstädte autofrei werden?", rounds: 2 };
+  if (value === null) return { topic: "Should city centers become car-free?", rounds: 2 };
   if (typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("Startwert braucht topic (1 bis 160 Zeichen) und rounds (ganze Zahl von 1 bis 5).");
+    throw new Error("The start value needs topic (1 to 160 characters) and rounds (an integer from 1 to 5).");
   }
   const settings = value as Record<string, unknown>;
   if (Object.keys(settings).some((key) => key !== "topic" && key !== "rounds")
     || typeof settings.topic !== "string" || !settings.topic.trim() || settings.topic.trim().length > 160
     || typeof settings.rounds !== "number" || !Number.isInteger(settings.rounds) || settings.rounds < 1 || settings.rounds > 5) {
-    throw new Error("Startwert braucht topic (1 bis 160 Zeichen) und rounds (ganze Zahl von 1 bis 5).");
+    throw new Error("The start value needs topic (1 to 160 characters) and rounds (an integer from 1 to 5).");
   }
   return { topic: settings.topic.trim(), rounds: settings.rounds };
 };
 
 const roleOf = (name: string): string => {
-  if (name === "mira") return "Du bist Mira und fragst neugierig nach.";
-  if (name === "jon") return "Du bist Jon und widersprichst höflich.";
-  return "Du bist Ada und suchst den gemeinsamen Nenner.";
+  if (name === "mira") return "You are Mira and you ask curious questions.";
+  if (name === "jon") return "You are Jon and you politely disagree.";
+  return "You are Ada and you look for common ground.";
 };
 
 export default defineActor(contract, {
@@ -42,15 +42,15 @@ export default defineActor(contract, {
     const catalog = await context.functions.model_list({});
     const profiles = catalog.profiles.filter((profile) => profile.driver === "agent" && profile.name !== "coordinator");
     const first = profiles[0];
-    if (!first) throw new Error("Keine Rolle außer coordinator; agent_spawn braucht eine.");
+    if (!first) throw new Error("No role other than coordinator; agent_spawn needs one.");
 
-    await context.functions.run_configure({ title: `Gesprächsrunde: ${topic}` });
+    await context.functions.run_configure({ title: `Conversation circle: ${topic}` });
 
     const participants: string[] = [];
     for (const name of ["mira", "jon", "ada"]) {
       const participant = await context.functions.agent_spawn({
         handle: name,
-        prompt: `${roleOf(name)} Antworte ausschließlich mit einem kurzen Satz als nächstem Gesprächsbeitrag.`,
+        prompt: `${roleOf(name)} Reply only with one short sentence as the next contribution to the conversation.`,
         profile: first.name,
         tools: [],
       });
@@ -70,10 +70,10 @@ export default defineActor(contract, {
 
     await context.functions.actor_input({
       actor: "@coordinator",
-      content: `Die Runde steht: ${participants.join(", ")} sind aufgestellt, die Fläche ist aufgeteilt. Thema: "${topic}". `
-        + `Führe genau ${rounds} Gesprächsrunden durch: in jeder Runde ${participants.join(", ")} in dieser Reihenfolge. `
-        + "Jeder erhält die bisherigen Beiträge. Ändere die Fläche nicht. "
-        + "Fasse das Gespräch am Ende in drei Sätzen zusammen.",
+      content: `The circle is ready: ${participants.join(", ")} are set up, the surface is split. Topic: "${topic}". `
+        + `Run exactly ${rounds} conversation rounds: in each round ${participants.join(", ")} in this order. `
+        + "Each one receives the previous contributions. Do not change the surface. "
+        + "At the end, summarize the conversation in three sentences.",
     });
 
     context.state.replace({ built: true });

package/plugins/ragents.reference/run-scripts/conversation-circle/tests/helpers.ts

@@ -13,7 +13,7 @@ export const setupContext = (profiles = [{ name: "coordinator", driver: "agent"
       return { name: value.name, actor: value.actor, views: 1, active: true };
     }
     return name === "model_list" ? {
-      profiles: profiles.map((profile) => ({ ...profile, description: "Testprofil", turnTimeoutMs: null,
+      profiles: profiles.map((profile) => ({ ...profile, description: "Test profile", turnTimeoutMs: null,
         isolateWorkspace: false, provider: "test", model: "test" })), models: [],
     } : name === "actor_input" ? [] : null;
   }]));

package/plugins/ragents.reference/run-scripts/conversation-circle/tests/program.test.ts

@@ -3,31 +3,31 @@ import test from "node:test";
 import program from "../src/server.ts";
 import { setupContext, startInput } from "./helpers.ts";
 
-test("Thema und Rundenzahl steuern Teilnehmer, Fläche und Auftrag", async () => {
+test("topic and number of rounds control participants, surface, and task", async () => {
   const { calls, context } = setupContext();
-  await program.onInput!(startInput({ topic: "Teamfrühstück", rounds: 3 }), context);
+  await program.onInput!(startInput({ topic: "Team breakfast", rounds: 3 }), context);
   assert.deepEqual(calls.filter((call) => call.name === "agent_spawn").map((call) => (call.input as { handle: string }).handle), ["mira", "jon", "ada"]);
-  assert.deepEqual(calls.find((call) => call.name === "run_configure")?.input, { title: "Gesprächsrunde: Teamfrühstück" });
+  assert.deepEqual(calls.find((call) => call.name === "run_configure")?.input, { title: "Conversation circle: Team breakfast" });
   const layout = calls.find((call) => call.name === "canvas_layout_replace")?.input as { root: unknown };
   assert.deepEqual(layout.root, { direction: "vertical", weights: [1, 1], children: [
     { entity: "@mira" },
     { direction: "horizontal", weights: [1, 1], children: [{ entity: "@jon" }, { entity: "@ada" }] },
   ] });
-  assert.match(JSON.stringify(calls.at(-1)), /genau 3 Gesprächsrunden/);
+  assert.match(JSON.stringify(calls.at(-1)), /exactly 3 conversation rounds/);
   assert.deepEqual(context.state.read(), { built: true });
   const completedCalls = calls.length;
   await program.onInput!(startInput(null), context);
   assert.equal(calls.length, completedCalls);
 });
 
-test("null hat einen ausdrücklichen Standard, ungültige Werte lösen keine Wirkung aus", async () => {
+test("null has an explicit default, invalid values have no effect", async () => {
   const initial = setupContext();
   await program.onInput!(startInput(null), initial.context);
-  assert.match(JSON.stringify(initial.calls), /Sollten Innenstädte autofrei werden/);
-  assert.match(JSON.stringify(initial.calls.at(-1)), /genau 2 Gesprächsrunden/);
+  assert.match(JSON.stringify(initial.calls), /Should city centers become car-free/);
+  assert.match(JSON.stringify(initial.calls.at(-1)), /exactly 2 conversation rounds/);
   for (const input of [{ topic: "Plan" }, { topic: "", rounds: 2 }, { topic: "Plan", rounds: 6 }, { topic: "Plan", rounds: 1.5 }, { topic: "Plan", rounds: 2, extra: true }, "Plan"]) {
     const { calls, context } = setupContext();
-    await assert.rejects(async () => program.onInput!(startInput(input), context), /Startwert braucht topic/);
+    await assert.rejects(async () => program.onInput!(startInput(input), context), /start value needs topic/);
     assert.deepEqual(calls, []);
     assert.deepEqual(context.state.read(), {});
   }

package/plugins/ragents.reference/run-scripts/learning-afternoon/RUN.md

@@ -1,24 +1,24 @@
 ---
-title: Lernnachmittag
-description: "Eine vorbereitete Parallelrunde zeigt zwei unabhängig arbeitende KI-Helfer und einen TypeScript-Sammler. Die Mini-App übernimmt einmalig je eine Antwort."
+title: Learning afternoon
+description: "A prepared parallel round shows two independently working AI helpers and a TypeScript collector. The mini-app takes over one answer from each exactly once."
 order: 150
 coordinator: false
-tags: Run-Scripts, Anwendungsfall, Konzeptdemo, Mini-Apps, TypeScript-Actors, Agententeams, Subscriptions, Primary-Actor
+tags: Run scripts, Use case, Concept demo, Mini-apps, TypeScript actors, Agent teams, Subscriptions, Primary actor
 ---
 
-Das vorbereitete TypeScript-Programm richtet zwei KI-Helfer ohne Werkzeuge ein und zeigt seine
-eigene Mini-App. Beide verwenden die Rolle `standard`. Ein Koordinator ist nicht nötig;
-der TypeScript-Actor steuert den Ablauf und ist der Primary-Actor.
+The prepared TypeScript program sets up two AI helpers without tools and shows its
+own mini-app. Both use the role `standard`. A coordinator is not needed;
+the TypeScript actor controls the flow and is the primary actor.
 
-Erst "Ideen sammeln" beauftragt die beiden Helfer: Helfer A schlägt ein einfaches Experiment
-vor, Helfer B ein kleines Lernquiz. Jeder liefert genau eine Idee für einen Lernnachmittag mit
-Grundschulkindern. Die Aufträge sind unabhängig und werden gleichzeitig abgeschickt. Die App
-zeigt den Stand jedes Helfers und übernimmt seine abgeschlossene Antwort in die gemeinsame
-Ergebnisliste. Die Ideen sind echte Modellantworten und werden nicht fachlich geprüft.
+Only "Collect ideas" assigns the two helpers: Helper A suggests a simple experiment,
+Helper B a small learning quiz. Each delivers exactly one idea for a learning afternoon with
+primary school children. The tasks are independent and are sent at the same time. The app
+shows the status of each helper and takes its completed answer into the shared
+result list. The ideas are real model answers and are not checked for subject-matter accuracy.
 
-Ein Fehler bei einem Helfer lässt das Ergebnis des anderen stehen. Leere Antworten und
-unterbrochene Modell-Turns erscheinen als Fehler. Der Ablauf startet einmal und wiederholt
-weder Aufträge noch fehlgeschlagene Antworten automatisch. Für neue Ideen beginnt ein neuer Run.
-Die Vorlage benötigt keine Startwerte und löst vor dem Button keinen Modellaufruf aus.
+An error in one helper leaves the result of the other in place. Empty answers and
+interrupted model turns appear as errors. The flow starts once and repeats
+neither tasks nor failed answers automatically. For new ideas, start a new run.
+The template needs no start values and triggers no model call before the button.
 
-Die Homepage verwendet dieselbe React-Ansicht mit ausdrücklich markierten Vorschaudaten.
+The homepage uses the same React view with explicitly marked preview data.

package/plugins/ragents.reference/run-scripts/learning-afternoon/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "type": "module",
   "ragents": {
-    "title": "Lernnachmittag",
+    "title": "Learning afternoon",
     "backend": "src/server.ts",
     "views": [{ "id": "main", "client": "src/client.tsx" }]
   }

package/plugins/ragents.reference/run-scripts/learning-afternoon/prompts/experiment.md

@@ -1 +1 @@
-Wenn Du die Experimentaufgabe erhältst, schlage eine Beobachtung vor, die Kinder mit einfachen Alltagsmaterialien gemeinsam machen können. Beschreibe das benötigte Material, die Durchführung und was die Kinder dabei entdecken können. Vermeide Feuer, gefährliche Stoffe und aufwendige Geräte.
+When you receive the experiment task, suggest an observation that children can make together with simple everyday materials. Describe the materials needed, the procedure, and what the children can discover. Avoid fire, dangerous substances, and elaborate equipment.

package/plugins/ragents.reference/run-scripts/learning-afternoon/prompts/helper.md

@@ -1,5 +1,5 @@
-Du lieferst genau eine konkrete Idee für einen Lernnachmittag mit Grundschulkindern. Zwei Helfer arbeiten unabhängig voneinander; die Anwendung sammelt ihre Antworten automatisch.
+You deliver exactly one concrete idea for a learning afternoon with primary school children. Two helpers work independently of each other; the application collects their answers automatically.
 
-Deine nächste Nachricht nennt Deine konkrete Aufgabe. Bearbeite ausschließlich diese Aufgabe, auch wenn der gemeinsame Ablauf weitere Schritte beschreibt. Übernimm weder die Aufgabe des anderen Helfers noch die Sammlung.
+Your next message names your concrete task. Work only on this task, even if the shared flow describes further steps. Take over neither the other helper's task nor the collection.
 
-Antworte auf Deutsch als kurzer normaler Text: ein Titel und zwei bis drei Sätze zu Material und Ablauf. Keine Rückfragen, keine Werkzeuge, keine weiteren Aufgaben. Wähle bei offenen Einzelheiten selbst eine einfache, altersgerechte Lösung. Halte den Vorschlag mit einfachen Materialien und ohne gefährliche Experimente umsetzbar.
+Answer in English as a short normal text: a title and two to three sentences on materials and procedure. No questions, no tools, no further tasks. For open details, choose a simple, age-appropriate solution yourself. Keep the suggestion feasible with simple materials and without dangerous experiments.

package/plugins/ragents.reference/run-scripts/learning-afternoon/prompts/quiz.md

@@ -1 +1 @@
-Wenn Du die Quizaufgabe erhältst, schlage ein kurzes gemeinsames Wissensspiel vor. Nenne ein kindgerechtes Thema, erkläre die Spielweise und gib eine kleine Beispielfrage. Das Spiel soll mit einfachen Materialien auskommen und alle Kinder beteiligen.
+When you receive the quiz task, suggest a short knowledge game to play together. Name a child-friendly topic, explain how the game is played, and give a small sample question. The game should need only simple materials and involve all children.

package/plugins/ragents.reference/run-scripts/learning-afternoon/src/server.ts

@@ -26,7 +26,7 @@ const contract = {
   }, { additionalProperties: false }),
   functions: {
     start: {
-      label: "Ideen sammeln",
+      label: "Collect ideas",
       input: Type.Object({}, { additionalProperties: false }),
       output: Type.Object({}, { additionalProperties: false }),
       capabilities: ["actor_input"],
@@ -61,12 +61,12 @@ export default defineActor(contract, {
   onInput: async (input, context) => {
     const state = context.state.read();
     if (state.board && !input.event && input.content !== startMarker) {
-      throw new Error("Der Lernnachmittag versteht keine freien Chatnachrichten. Verwende den Startknopf der Mini-App; für neue Ideen ist ein neuer Run nötig.");
+      throw new Error("The learning afternoon does not understand free chat messages. Use the start button of the mini-app; new ideas need a new run.");
     }
     if (!state.board) {
       const catalog = await context.functions.model_list({});
       const profile = catalog.profiles.find((entry) => entry.driver === "agent" && entry.name === "standard");
-      if (!profile) throw new Error("Die Rolle standard fehlt.");
+      if (!profile) throw new Error("The role standard is missing.");
       const prompt = await workflowInstructions(learningWorkflow, "helper", readPrompt);
       const helpers = await Promise.all(initialState.helpers.map(async (helper) => {
         const actor = await context.functions.agent_spawn({ handle: `learning-${helper.id}`, displayName: helper.label, profile: profile.name, prompt, tools: [] });
@@ -92,11 +92,11 @@ export default defineActor(contract, {
       });
       const results = await Promise.allSettled(state.board.helpers.map(async (helper): Promise<HelperState> => {
         const step = helperSteps.find((entry) => entry.id === helper.id);
-        if (!step) throw new Error(`Unbekannter Helfer: ${helper.id}`);
+        if (!step) throw new Error(`Unknown helper: ${helper.id}`);
         const content = step.goal;
         const events = await context.functions.actor_input({ actor: `@learning-${helper.id}`, content });
         const queued = events.find((event) => event.type === "actor.input.enqueued");
-        if (!queued || queued.type !== "actor.input.enqueued") throw new Error("Der Auftrag wurde nicht bestätigt.");
+        if (!queued || queued.type !== "actor.input.enqueued") throw new Error("The task was not confirmed.");
         return { ...helper, inputId: queued.payload.inputId, status: "working" };
       }));
       const helpers = state.board.helpers.map((helper, index): HelperState => {
@@ -104,7 +104,7 @@ export default defineActor(contract, {
         return result.status === "fulfilled" ? result.value : { ...helper, status: "error", error: result.reason instanceof Error ? result.reason.message : String(result.reason) };
       });
       const board = boardWith(helpers);
-      if (board.phase !== "working") await context.functions.event_unsubscribe({ subscriptionId: subscription.subscriptionId, reason: "Beide Aufträge sind beendet." });
+      if (board.phase !== "working") await context.functions.event_unsubscribe({ subscriptionId: subscription.subscriptionId, reason: "Both tasks have ended." });
       context.state.replace({ board, subscriptionId: subscription.subscriptionId });
       return;
     }
@@ -114,7 +114,7 @@ export default defineActor(contract, {
     const helper = state.board.helpers.find((entry) => entry.actorId === event.sourceActorId && entry.status === "working");
     if (!helper) return;
     const next = await (async (): Promise<HelperState | undefined> => {
-      if (event.type === "actor.stopped") return { ...helper, status: "error", error: "Der Helfer wurde gestoppt." };
+      if (event.type === "actor.stopped") return { ...helper, status: "error", error: "The helper was stopped." };
       if (event.type !== "turn.finished" && event.type !== "turn.interrupted") return;
       const payload = event.payload;
       const turnId = payload.turnId;
@@ -126,12 +126,12 @@ export default defineActor(contract, {
       const text = events.filter((entry) => entry.type === "model.output.completed" && entry.payload.turnId === turnId)
         .map((entry) => typeof entry.payload.text === "string" ? entry.payload.text.trim() : "").filter(Boolean).join("\n\n");
       if (event.type === "turn.finished" && payload.outcome === "completed" && text) return { ...helper, text, status: "complete" };
-      const error = typeof payload.reason === "string" && payload.reason.trim() ? payload.reason : "Der Helfer hat keine Idee geliefert.";
+      const error = typeof payload.reason === "string" && payload.reason.trim() ? payload.reason : "The helper delivered no idea.";
       return { ...helper, status: "error", error };
     })();
     if (!next) return;
     const board = boardWith(state.board.helpers.map((entry) => entry.id === next.id ? next : entry));
-    if (board.phase !== "working") await context.functions.event_unsubscribe({ subscriptionId: state.subscriptionId!, reason: "Beide Aufträge sind beendet." });
+    if (board.phase !== "working") await context.functions.event_unsubscribe({ subscriptionId: state.subscriptionId!, reason: "Both tasks have ended." });
     context.state.replace({ ...state, board });
   },
 });

package/plugins/ragents.reference/run-scripts/learning-afternoon/tests/program.test.ts

@@ -22,7 +22,7 @@ function setup(options: { missingProfile?: boolean; failDispatch?: string; befor
     "model_list", "agent_spawn", "canvas_layout_replace", "run_configure", "actor_input", "event_subscribe", "event_unsubscribe", "event_query",
   ].map((name) => [name, async (input: unknown) => {
     calls.push({ name, input });
-    if (name === "model_list") return { profiles: options.missingProfile ? [] : [{ name: "standard", driver: "agent", description: "Testprofil", turnTimeoutMs: null, isolateWorkspace: false, provider: "test", model: "test" }], models: [] };
+    if (name === "model_list") return { profiles: options.missingProfile ? [] : [{ name: "standard", driver: "agent", description: "Test profile", turnTimeoutMs: null, isolateWorkspace: false, provider: "test", model: "test" }], models: [] };
     if (name === "agent_spawn") {
       const handle = (input as { handle: string }).handle;
       return { id: `actor-${handle}`, handle };
@@ -32,7 +32,7 @@ function setup(options: { missingProfile?: boolean; failDispatch?: string; befor
     if (name === "actor_input") {
       const actor = (input as { actor: string }).actor;
       await options.beforeDispatch?.(actor);
-      if (actor === options.failDispatch) throw new Error("Auftrag konnte nicht gesendet werden.");
+      if (actor === options.failDispatch) throw new Error("Task could not be sent.");
       return [{ type: "actor.input.enqueued", payload: { actorId: `actor-${actor.slice(1)}`, inputId: `input-${actor.slice(1)}` } }];
     }
     return null;
@@ -56,7 +56,7 @@ async function complete(context: ReturnType<typeof setup>["context"], helper: st
   await program.onInput(eventOf(helper, "turn.finished", { outcome: "completed" }), context);
 }
 
-test("Start richtet nur zwei reine Helfer und die eigene App ein; erst der Button stellt einen Auftrag an den Besitzer", async () => {
+test("start sets up only two plain helpers and its own app; only the button sends a task to the owner", async () => {
   const { context, calls } = setup();
   await program.onInput(setupInput, context);
   assert.equal(context.state.read().board?.phase, "ready");
@@ -68,7 +68,7 @@ test("Start richtet nur zwei reine Helfer und die eigene App ein; erst der Butto
   assert.equal(calls.some((call) => call.name === "actor_input" || call.name === "event_subscribe"), false);
   const before = structuredClone(context.state.read());
   const callCount = calls.length;
-  await assert.rejects(async () => program.onInput(setupInput, context), /keine freien Chatnachrichten/);
+  await assert.rejects(async () => program.onInput(setupInput, context), /does not understand free chat messages/);
   assert.deepEqual(context.state.read(), before);
   assert.equal(calls.length, callCount);
   await program.functions.start({}, context);
@@ -76,13 +76,13 @@ test("Start richtet nur zwei reine Helfer und die eigene App ein; erst der Butto
   assert.equal(context.state.read().board?.phase, "ready");
 });
 
-test("der Input-Handler abonniert zuerst und sendet beide unabhängigen Aufträge parallel genau einmal", async () => {
+test("the input handler subscribes first and sends both independent tasks in parallel exactly once", async () => {
   const pending: (() => void)[] = [];
   const { context, calls } = setup({ beforeDispatch: () => new Promise<void>((resolve) => pending.push(resolve)) });
   await program.onInput(setupInput, context);
   const starting = program.onInput(startInput, context);
   for (let attempt = 0; attempt < 20 && pending.length < 2; attempt++) await Promise.resolve();
-  assert.equal(pending.length, 2, "Beide Inputs beginnen, bevor einer fertig ist.");
+  assert.equal(pending.length, 2, "Both inputs begin before one finishes.");
   assert.equal(calls.filter((call) => call.name === "event_subscribe").length, 1);
   for (const resolve of pending) resolve();
   await starting;
@@ -93,104 +93,104 @@ test("der Input-Handler abonniert zuerst und sendet beide unabhängigen Aufträg
 });
 
 for (const phase of ["ready", "working", "complete"]) {
-  test(`freie Chatnachrichten werden bei ${phase} abgelehnt und erhalten die Ideen`, async () => {
+  test(`free chat messages are rejected when ${phase} and keep the ideas`, async () => {
     const { context, calls } = setup();
     if (phase === "ready") {
       await program.onInput(setupInput, context);
     } else {
       await begin(context);
-      await complete(context, "experiment", "Die Experimentidee ist fertig.");
-      if (phase === "complete") await complete(context, "quiz", "Die Quizidee ist fertig.");
+      await complete(context, "experiment", "The experiment idea is ready.");
+      if (phase === "complete") await complete(context, "quiz", "The quiz idea is ready.");
     }
     assert.equal(context.state.read().board?.phase, phase);
     const before = structuredClone(context.state.read());
     const callCount = calls.length;
-    const content = "Sammle bitte noch einmal neue Ideen für den Lernnachmittag.";
-    await assert.rejects(async () => program.onInput(inputOf(content), context), /keine freien Chatnachrichten.*Startknopf.*neuer Run/);
+    const content = "Please collect new ideas for the learning afternoon again.";
+    await assert.rejects(async () => program.onInput(inputOf(content), context), /does not understand free chat messages.*start button.*new run/);
     assert.deepEqual(context.state.read(), before);
     assert.equal(calls.length, callCount);
     if (phase === "ready") {
       await program.onInput(startInput, context);
       assert.equal(context.state.read().board?.phase, "working");
     } else if (phase === "working") {
-      await complete(context, "quiz", "Die Quizidee ist fertig.");
+      await complete(context, "quiz", "The quiz idea is ready.");
       assert.equal(context.state.read().board?.phase, "complete");
-      assert.equal(context.state.read().board?.helpers[0]?.text, "Die Experimentidee ist fertig.");
+      assert.equal(context.state.read().board?.helpers[0]?.text, "The experiment idea is ready.");
     }
   });
 }
 
 for (const order of [["experiment", "quiz"], ["quiz", "experiment"]]) {
-  test(`sammelt Antworten in beliebiger Reihenfolge: ${order.join(", ")}`, async () => {
+  test(`collects answers in any order: ${order.join(", ")}`, async () => {
     const { context, calls } = setup();
     await begin(context);
-    await complete(context, order[0]!, "Erste echte Antwort");
+    await complete(context, order[0]!, "First real answer");
     assert.equal(context.state.read().board?.phase, "working");
-    await complete(context, order[1]!, "Zweite echte Antwort");
+    await complete(context, order[1]!, "Second real answer");
     const board = context.state.read().board!;
     assert.equal(board.phase, "complete");
-    assert.equal(board.helpers.find((helper) => helper.id === order[0])?.text, "Erste echte Antwort");
-    assert.equal(board.helpers.find((helper) => helper.id === order[1])?.text, "Zweite echte Antwort");
+    assert.equal(board.helpers.find((helper) => helper.id === order[0])?.text, "First real answer");
+    assert.equal(board.helpers.find((helper) => helper.id === order[1])?.text, "Second real answer");
     assert.equal(calls.filter((call) => call.name === "event_unsubscribe").length, 1);
-    for (let count = 0; count < 10; count++) await complete(context, order[0]!, "Späte Antwort");
+    for (let count = 0; count < 10; count++) await complete(context, order[0]!, "Late answer");
     assert.deepEqual(context.state.read().board, board);
     assert.equal(calls.filter((call) => call.name === "actor_input").length, 2);
   });
 }
 
-test("ignoriert falsche Actors, Inputs, Turns, Abos und doppelte Antworten", async () => {
+test("ignores wrong actors, inputs, turns, subscriptions, and duplicate answers", async () => {
   const { context } = setup();
   await program.onInput(setupInput, context);
   await program.onInput(startInput, context);
-  record(context, "experiment", "turn.started", { inputId: "fremd", turnId: "fremd" });
-  record(context, "experiment", "model.output.completed", { text: "Fremd", turnId: "fremd" });
+  record(context, "experiment", "turn.started", { inputId: "foreign", turnId: "foreign" });
+  record(context, "experiment", "model.output.completed", { text: "Foreign", turnId: "foreign" });
   record(context, "experiment", "turn.started", { inputId: "input-learning-experiment" });
-  record(context, "experiment", "model.output.completed", { text: "Meine Idee" });
+  record(context, "experiment", "model.output.completed", { text: "My idea" });
   const before = context.state.read();
   await program.onInput(eventOf("foreign", "turn.finished", { outcome: "completed" }), context);
-  await program.onInput(eventOf("experiment", "turn.finished", { outcome: "completed", turnId: "fremd" }), context);
-  await program.onInput({ ...eventOf("experiment", "turn.finished", { outcome: "completed" }), subscriptionId: "fremd" }, context);
+  await program.onInput(eventOf("experiment", "turn.finished", { outcome: "completed", turnId: "foreign" }), context);
+  await program.onInput({ ...eventOf("experiment", "turn.finished", { outcome: "completed" }), subscriptionId: "foreign" }, context);
   assert.deepEqual(context.state.read(), before);
   const answer = eventOf("experiment", "turn.finished", { outcome: "completed" });
   await program.onInput(answer, context);
   await program.onInput(answer, context);
-  assert.equal(context.state.read().board?.helpers[0]?.text, "Meine Idee");
+  assert.equal(context.state.read().board?.helpers[0]?.text, "My idea");
   assert.equal(context.state.read().board?.helpers[0]?.status, "complete");
 });
 
 for (const ending of ["failed", "interrupted", "empty", "stopped"]) {
-  test(`ein ${ending}-Ergebnis erhält die erfolgreiche Idee des anderen Helfers`, async () => {
+  test(`a ${ending} result keeps the successful idea of the other helper`, async () => {
     const { context, calls } = setup();
     await begin(context);
-    await complete(context, "quiz", "Das Quiz ist fertig.");
-    await program.onInput(eventOf("experiment", ending === "stopped" ? "actor.stopped" : ending === "interrupted" ? "turn.interrupted" : "turn.finished", { outcome: ending === "empty" ? "completed" : "failed", ...(ending === "empty" ? {} : { reason: "Modellfehler" }) }), context);
+    await complete(context, "quiz", "The quiz is ready.");
+    await program.onInput(eventOf("experiment", ending === "stopped" ? "actor.stopped" : ending === "interrupted" ? "turn.interrupted" : "turn.finished", { outcome: ending === "empty" ? "completed" : "failed", ...(ending === "empty" ? {} : { reason: "Model error" }) }), context);
     assert.equal(context.state.read().board?.phase, "error");
     assert.equal(context.state.read().board?.helpers[0]?.status, "error");
     assert.ok(context.state.read().board?.helpers[0]?.error);
-    assert.equal(context.state.read().board?.helpers[1]?.text, "Das Quiz ist fertig.");
+    assert.equal(context.state.read().board?.helpers[1]?.text, "The quiz is ready.");
     assert.equal(calls.filter((call) => call.name === "actor_input").length, 2);
     assert.equal(calls.filter((call) => call.name === "event_unsubscribe").length, 1);
   });
 }
 
-test("ein gescheiterter Input verhindert den Auftrag des anderen Helfers nicht", async () => {
+test("a failed input does not prevent the other helper's task", async () => {
   const { context } = setup({ failDispatch: "@learning-experiment" });
   await begin(context);
   assert.equal(context.state.read().board?.helpers[0]?.status, "error");
   assert.equal(context.state.read().board?.phase, "working");
-  await complete(context, "quiz", "Eine Quizidee.");
+  await complete(context, "quiz", "A quiz idea.");
   assert.equal(context.state.read().board?.phase, "error");
   assert.equal(context.state.read().board?.helpers[1]?.status, "complete");
 });
 
-test("ohne Standardprofil wird kein Helfer angelegt", async () => {
+test("without a standard profile no helper is created", async () => {
   const { context, calls } = setup({ missingProfile: true });
-  await assert.rejects(async () => program.onInput(setupInput, context), /Rolle standard fehlt/);
+  await assert.rejects(async () => program.onInput(setupInput, context), /role standard is missing/);
   assert.deepEqual(calls.map((call) => call.name), ["model_list"]);
   assert.deepEqual(context.state.read(), {});
 });
 
-test("der gemeinsame Ablauf liefert Helferaufträge, Prompt und parallele Graphzweige", async () => {
+test("the shared flow provides helper tasks, prompt, and parallel graph branches", async () => {
   const { learningWorkflow, helperSteps } = await import("../src/workflow.ts");
   const { learningWorkflowState, initialState } = await import("../src/state.ts");
   const { workflowGraph } = await import("@ragents/workflow");
@@ -200,15 +200,15 @@ test("der gemeinsame Ablauf liefert Helferaufträge, Prompt und parallele Graphz
   assert.equal(spawns.length, helperSteps.length);
   for (const spawn of spawns) {
     const prompt = (spawn.input as { prompt: string }).prompt;
-    assert.match(prompt, /Bearbeite ausschließlich diese Aufgabe/);
-    assert.match(prompt, /Beispielfrage/);
-    assert.match(prompt, /gefährliche Stoffe/);
+    assert.match(prompt, /Work only on this task/);
+    assert.match(prompt, /sample question/);
+    assert.match(prompt, /dangerous substances/);
   }
   assert.deepEqual(calls.filter((call) => call.name === "actor_input").map((call) => (call.input as { content: string }).content), helperSteps.map((step) => step.goal));
   const initial = workflowGraph(learningWorkflow, learningWorkflowState(initialState));
   assert.ok(initial.nodes.every((node) => node.status === "pending"));
   assert.deepEqual(initial.edges.map((edge) => [edge.source, edge.target]), [["experiment", "collect"], ["quiz", "collect"]]);
-  await complete(context, "quiz", "Eine Quizidee.");
+  await complete(context, "quiz", "A quiz idea.");
   const partial = workflowGraph(learningWorkflow, learningWorkflowState(context.state.read().board!));
   assert.deepEqual(partial.nodes.map((node) => [node.id, node.status]), [["experiment", "active"], ["quiz", "done"], ["collect", "active"]]);
   await program.onInput(eventOf("experiment", "actor.stopped", {}), context);

package/plugins/ragents.reference/run-scripts/moderated-round/RUN.md

@@ -1,12 +1,12 @@
 ---
-title: Moderierte Runde ohne Koordinator
-description: "Ein vorbereiteter Aufbau zeigt einen Run, der von Anfang an ohne Koordinator arbeitet. Der Moderator wird Primary-Actor und direkter Ansprechpartner im Chat."
+title: Moderated round without coordinator
+description: "A prepared setup shows a run that works without a coordinator from the start. The moderator becomes the primary actor and your direct contact in the chat."
 order: 130
 coordinator: false
-tags: Run-Scripts, Anwendungsfall, Konzeptdemo, Primary-Actor, Agententeams
+tags: Run scripts, Use case, Concept demo, Primary actor, Agent teams
 ---
 
-Referenzfall für `coordinator: false`: der Host spawnt keinen Koordinator, das Script wählt mit
-`run_configure` den Moderator als Primary-Actor und setzt den Run-Titel. Der Chat bindet sich, sobald
-der Primary-Actor feststeht. Der Moderator behält seinen eigenen Actor-Prompt auch als Primary-Actor; den konkreten Auftrag
-erhält er über den ersten ActorInput. Ein Startwert `{ "topic": "..." }` setzt das Thema.
+Reference case for `coordinator: false`: the host spawns no coordinator, the script uses
+`run_configure` to choose the moderator as primary actor and sets the run title. The chat binds as soon as
+the primary actor is determined. The moderator keeps its own actor prompt even as primary actor; it receives the concrete task
+through the first ActorInput. A start value `{ "topic": "..." }` sets the topic.

package/plugins/ragents.reference/run-scripts/moderated-round/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "type": "module",
   "ragents": {
-    "title": "Moderierte Runde ohne Koordinator",
+    "title": "Moderated round without coordinator",
     "backend": "src/server.ts"
   }
 }

package/plugins/ragents.reference/run-scripts/moderated-round/src/server.ts

@@ -10,7 +10,7 @@ const contract = {
 type Start = { input: { topic?: string } | null };
 
 const guestOf = (name: string): string =>
-  name === "kai" ? "Du bist Kai, pragmatisch und knapp." : "Du bist Lena, gründlich und abwägend.";
+  name === "kai" ? "You are Kai, pragmatic and brief." : "You are Lena, thorough and deliberate.";
 
 export default defineActor(contract, {
   functions: {},
@@ -18,17 +18,17 @@ export default defineActor(contract, {
     const state = context.state.read();
     if (state && state.built) return;
     const start = JSON.parse(input.content) as Start;
-    const topic = start.input && start.input.topic ? start.input.topic : "Was macht ein gutes Team aus?";
+    const topic = start.input && start.input.topic ? start.input.topic : "What makes a good team?";
 
     const catalog = await context.functions.model_list({});
     const profiles = catalog.profiles.filter((profile) => profile.driver === "agent" && profile.name !== "coordinator");
     const first = profiles[0];
-    if (!first) throw new Error("Keine Rolle außer coordinator; agent_spawn braucht eine.");
+    if (!first) throw new Error("No role other than coordinator; agent_spawn needs one.");
 
     const moderator = await context.functions.agent_spawn({
       handle: "moderator",
       displayName: "Moderator",
-      prompt: "Du moderierst eine Gesprächsrunde zwischen dem Benutzer und zwei Gästen.",
+      prompt: "You moderate a conversation circle between the user and two guests.",
       profile: first.name,
       tools: ["actor_input", "event_subscribe", "event_unsubscribe", "event_subscription_list"],
     });
@@ -36,7 +36,7 @@ export default defineActor(contract, {
     for (const name of ["kai", "lena"]) {
       const guest = await context.functions.agent_spawn({
         handle: name,
-        prompt: `${guestOf(name)} Antworte mit höchstens zwei Sätzen.`,
+        prompt: `${guestOf(name)} Reply with at most two sentences.`,
         profile: first.name,
         tools: [],
       });
@@ -44,15 +44,15 @@ export default defineActor(contract, {
     }
 
     await context.functions.run_configure({
-      title: `Moderierte Runde: ${topic}`,
+      title: `Moderated round: ${topic}`,
       primaryActor: `@${moderator.handle}`,
     });
 
     await context.functions.actor_input({
       actor: `@${moderator.handle}`,
-      content: "Du bist der Moderator dieses Runs und sprichst direkt mit dem Benutzer im Chat; einen Koordinator gibt es nicht. "
-        + `Deine Gäste sind ${guests.join(" und ")}. Hole ihre Beiträge ein und beziehe sie in die Gesprächsrunde ein. `
-        + `Thema: "${topic}". Begrüße den Benutzer mit zwei Sätzen, nenne das Thema und frage, ob er die erste Frage stellt oder du beginnen sollst.`,
+      content: "You are the moderator of this run and talk directly with the user in the chat; there is no coordinator. "
+        + `Your guests are ${guests.join(" and ")}. Gather their contributions and include them in the conversation circle. `
+        + `Topic: "${topic}". Greet the user with two sentences, name the topic, and ask whether they want to ask the first question or whether you should begin.`,
     });
 
     context.state.replace({ built: true });

package/plugins/ragents.reference/run-scripts/moderated-round/tests/helpers.ts

@@ -13,7 +13,7 @@ export const setupContext = (profiles = [{ name: "coordinator", driver: "agent"
       return { name: value.name, actor: value.actor, views: 1, active: true };
     }
     return name === "model_list" ? {
-      profiles: profiles.map((profile) => ({ ...profile, description: "Testprofil", turnTimeoutMs: null,
+      profiles: profiles.map((profile) => ({ ...profile, description: "Test profile", turnTimeoutMs: null,
         isolateWorkspace: false, provider: "test", model: "test" })), models: [],
     } : name === "actor_input" ? [] : null;
   }]));