@schlenkr/ragents 0.1.9 → 0.1.11

package/plugins/ragents.orchestration/web/run-panel/addressee-tree.ts

@@ -17,21 +17,21 @@ export type AddresseeNode = AddresseeActorNode | AddresseeGroupNode;
 
 export type AddresseeStatus = "running" | "input" | "waiting" | "stopped";
 
-/** Ab so vielen gleichartigen Geschwistern fasst der Baum sie zu einer Gruppe zusammen. */
+/** From this many similar siblings on, the tree combines them into a group. */
 export const ADDRESSEE_GROUP_MIN = 4;
-/** Erst bei mehr Einträgen erscheint die Suche. */
+/** The search appears only with more entries than this. */
 export const ADDRESSEE_SEARCH_ABOVE = 12;
 const SUMMARY_LENGTH = 90;
 
 const STATUS_WORDS: Readonly<Record<AddresseeStatus, readonly [one: string, many: string]>> = {
-  running: ["arbeitet", "arbeiten"],
-  input: ["wartet auf Eingabe", "warten auf Eingabe"],
-  waiting: ["wartet", "warten"],
-  stopped: ["gestoppt", "gestoppt"],
+  running: ["working", "working"],
+  input: ["waiting for input", "waiting for input"],
+  waiting: ["waiting", "waiting"],
+  stopped: ["stopped", "stopped"],
 };
 const STATUS_ORDER: readonly AddresseeStatus[] = ["running", "input", "waiting", "stopped"];
 
-const lower = (text: string) => text.toLocaleLowerCase("de-DE");
+const lower = (text: string) => text.toLocaleLowerCase("en-US");
 
 const shortened = (text: string): string => {
   const line = text.split("\n").map((entry) => entry.replace(/\s+/g, " ").trim()).find((entry) => entry !== "") ?? "";
@@ -48,7 +48,7 @@ export const addresseeStatus = (view: RunView, actor: RunActor): AddresseeStatus
 
 export const addresseeStatusWord = (status: AddresseeStatus, count = 1): string => STATUS_WORDS[status][count === 1 ? 0 : 1];
 
-/** Zählt die Zustände einer Gruppe in fester Reihenfolge, etwa "3 arbeiten, 34 warten". */
+/** Counts the states of a group in a fixed order, e.g. "3 working, 34 waiting". */
 export const addresseeStatusCounts = (view: RunView, actors: readonly RunActor[]): string => {
   const counts = new Map<AddresseeStatus, number>();
   for (const status of actors.map((actor) => addresseeStatus(view, actor))) counts.set(status, (counts.get(status) ?? 0) + 1);
@@ -58,7 +58,7 @@ export const addresseeStatusCounts = (view: RunView, actors: readonly RunActor[]
   }).join(", ");
 };
 
-/** Die Kurzbeschreibung je Actor: die beim Erzeugen gesetzte, sonst der gekürzte erste Auftrag, sonst ein abweichender Anzeigename. */
+/** The short description per actor: the one set on creation, otherwise the shortened first task, otherwise a differing display name. */
 export const addresseeSummaries = (view: RunView): ((actor: RunActor) => string | undefined) => {
   const firstInputs = new Map<string, { sequence: number; content: string }>();
   for (const input of view.inputs) {
@@ -76,7 +76,7 @@ export const addresseeSummaries = (view: RunView): ((actor: RunActor) => string
   };
 };
 
-/** Der nächste Erzeuger nach `createdBy`, der selbst im Baum steht; ein Mensch oder ein unbekannter Erzeuger macht den Actor zur Wurzel. */
+/** The nearest creator along `createdBy` that is itself in the tree; a human or an unknown creator makes the actor a root. */
 export const addresseeParentId = (byId: ReadonlyMap<string, RunActor>, included: ReadonlySet<string>, actor: RunActor): string | null => {
   const visited = new Set([actor.id]);
   let current = actor.createdBy;
@@ -105,7 +105,7 @@ const groupLabel = (handles: readonly string[]): string => {
   return `@${stem}*`;
 };
 
-/** Wer hat wen erzeugt: Koordinator oben, Unteragenten darunter, gleichartige Geschwister (Art und Handle-Stamm) als Gruppe. */
+/** Who created whom: coordinator on top, subagents below, similar siblings (kind and handle stem) as a group. */
 export const addresseeTree = (view: RunView, actors: readonly RunActor[]): AddresseeNode[] => {
   const byId = new Map(view.actors.map((actor) => [actor.id, actor]));
   const included = new Set(actors.map((actor) => actor.id));
@@ -138,7 +138,7 @@ export const addresseeTree = (view: RunView, actors: readonly RunActor[]): Addre
   return level(null);
 };
 
-/** Die Actors, die zur Suche passen, samt ihren Erzeugern im Baum, damit jeder Treffer an seinem Platz steht. */
+/** The actors matching the search, together with their creators in the tree, so every match stands in its place. */
 export const addresseeMatches = (view: RunView, actors: readonly RunActor[], query: string, summary: (actor: RunActor) => string | undefined): RunActor[] => {
   const words = lower(query).trim().split(/\s+/).filter(Boolean);
   if (words.length === 0) return [...actors];
@@ -158,7 +158,7 @@ export const addresseeMatches = (view: RunView, actors: readonly RunActor[], que
   return actors.filter((actor) => kept.has(actor.id));
 };
 
-/** Ob ein Actor in einem Zweig steckt, etwa damit eine Gruppe mit dem gewählten Actor offen startet. */
+/** Whether an actor is in a branch, e.g. so a group containing the selected actor starts open. */
 export const addresseeNodeContains = (node: AddresseeNode, actorId: string): boolean =>
   node.kind === "actor"
     ? node.actor.id === actorId || node.children.some((child) => addresseeNodeContains(child, actorId))

package/plugins/ragents.orchestration/web/run-panel/run-panel-actors.ts

@@ -2,7 +2,7 @@ import type { SurfaceElementDefinition } from "@ragents/web/PluginRegistry";
 import { actorVisibleInHeader, type ActorHeaderMode } from "../actor-header-settings";
 import { chatPrimaryId, type RunActor, type RunView } from "@ragents/web/run-view";
 
-/** Die Actors der Chip-Reihe: Koordinator zuerst, dann in Anlegereihenfolge; ohne Prüfrecht nur LLM-Agenten. */
+/** The actors of the chip row: coordinator first, then in creation order; without the inspect right only LLM agents. */
 export const runPanelActors = (view: RunView, inspect: boolean): RunActor[] => {
   const candidates = view.actors.filter((actor) => actor.kind !== "human" && (inspect || actor.kind === "agent"));
   const primaryId = chatPrimaryId(view);
@@ -17,7 +17,7 @@ export interface RunPanelActorFilter {
   selectedId: string | undefined;
 }
 
-/** Sichtbar nach der Actor-Anzeige der Fläche; der Koordinator und der gewählte Actor bleiben immer als Chip da. */
+/** Visible according to the surface's actor display; the coordinator and the selected actor always stay as a chip. */
 export const partitionRunPanelActors = (actors: readonly RunActor[], filter: RunPanelActorFilter): { shown: RunActor[]; hidden: RunActor[] } => {
   const shown: RunActor[] = [];
   const hidden: RunActor[] = [];
@@ -34,6 +34,6 @@ export const pendingInputCount = (view: RunView, actorId: string): number =>
 export const pendingActionCount = (view: RunView, askedBy: string): number =>
   view.actions.filter((action) => action.status === "pending" && action.askedBy === askedBy).length;
 
-/** Ein Chip trägt ein Ausrufezeichen, wenn eine Host-Bestätigung oder eine Aktion des Actors auf eine Eingabe wartet. */
+/** A chip carries an exclamation mark when a host confirmation or an action of the actor waits for input. */
 export const elementNeedsAttention = (view: RunView | undefined, definition: SurfaceElementDefinition, confirmationPending: boolean): boolean =>
   confirmationPending || (view !== undefined && definition.anchorActorId !== undefined && pendingActionCount(view, definition.anchorActorId) > 0);

package/plugins/ragents.orchestration/web/run-panel/run-panel-settings.ts

@@ -1,6 +1,6 @@
 import { createLocalStorageSetting } from "@ragents/web/lib/local-storage-setting";
 
-/** Verhalten des Run-Panels: ab welcher Breite der Chat neben der Mini-App liegt und wie das Sheet auf die Maus reagiert. */
+/** Behavior of the run panel: from which width the chat sits next to the mini-app and how the sheet reacts to the mouse. */
 export interface RunPanelSettings {
   sideWidth: number;
   openDelay: number;
@@ -26,7 +26,7 @@ export function parseRunPanelSettings(raw: string | null): RunPanelSettings {
     || !("sideWidth" in value) || !inRange(value.sideWidth, RUN_PANEL_SETTINGS_LIMITS.sideWidth)
     || !("openDelay" in value) || !inRange(value.openDelay, RUN_PANEL_SETTINGS_LIMITS.openDelay)
     || !("closeDelay" in value) || !inRange(value.closeDelay, RUN_PANEL_SETTINGS_LIMITS.closeDelay)) {
-    throw new Error("Die Einstellungen des Run-Panels sind ungültig: Breite 400 bis 4000 Pixel, Verzögerungen 0 bis 5000 beziehungsweise 10000 Millisekunden, ganze Zahlen.");
+    throw new Error("The run panel settings are invalid: width 400 to 4000 pixels, delays 0 to 5000 and 10000 milliseconds respectively, integers.");
   }
   return value as RunPanelSettings;
 }

package/plugins/ragents.orchestration/web/run-panel/run-panel-startup.ts

@@ -2,15 +2,15 @@ import { useEffect, useState } from "react";
 import type { Message } from "quassel/events";
 import type { SurfaceStartupState } from "../surface-startup";
 
-/** So lange überbrückt der Ladezustand eine beendete Arbeit, bis die Run-Ansicht dem Startstatus nachgezogen hat. */
+/** How long the loading state bridges finished work until the run view has caught up with the start status. */
 export const STARTUP_SETTLE_MS = 1500;
 
-/** Gesprächsbeiträge und Rückfragen beenden den Aufbau; Systemzeilen und Arbeitsschritte gehören noch zu ihm. */
+/** Conversation messages and questions end the setup; system lines and work steps still belong to it. */
 export const chatShowsContent = (messages: readonly Message[]): boolean => messages.some((message) =>
   message.role === "user" || message.role === "action"
   || (message.role === "assistant" && (message.text.trim() !== "" || (message.attachments?.length ?? 0) > 0)));
 
-/** Der Ladezustand des Run-Panels bis zum ersten Inhalt; danach kommt er für diesen Run nicht wieder. */
+/** The run panel's loading state until the first content; afterwards it does not return for this run. */
 export function useRunPanelStartup(state: SurfaceStartupState | undefined, connected: boolean, content: boolean): SurfaceStartupState | undefined {
   const [contentSeen, setContentSeen] = useState(content);
   const [held, setHeld] = useState<SurfaceStartupState>();

package/plugins/ragents.orchestration/web/run-panel/run-panel-state.ts

@@ -1,12 +1,12 @@
 import { createLocalStorageSetting } from "@ragents/web/lib/local-storage-setting";
 
-/** Die gewählte Ansicht des Run-Panels: nur Chat, Chat unten als Sheet oder Chat rechts, sofern das Run-Panel breit genug ist. */
+/** The chosen view of the run panel: chat only, chat at the bottom as a sheet, or chat on the right if the run panel is wide enough. */
 export type RunPanelChatMode = "chat" | "bottom" | "side";
 
-/** Wie der Chat zur Mini-App liegt: allein, daneben oder als Sheet darüber. */
+/** How the chat relates to the mini-app: alone, next to it, or as a sheet above it. */
 export type ChatLayout = "full" | "side" | "floating";
 
-/** Persönlicher Zustand je Run: Mini-App, Actor, Chat-Lage, Seitenbreite und ausgeklappte Sheet-Höhe. */
+/** Personal state per run: mini-app, actor, chat position, side width and expanded sheet height. */
 export interface RunPanelState {
   element: string | null;
   actor: string | null;
@@ -17,7 +17,7 @@ export interface RunPanelState {
 
 export const CHAT_MIN_WIDTH = 280;
 export const CHAT_DEFAULT_WIDTH = 380;
-/** Neben dem Chat bleibt immer Platz für ein Stück Mini-App. */
+/** Next to the chat there is always room for a piece of mini-app. */
 export const STAGE_MIN_WIDTH = 300;
 
 export const DEFAULT_RUN_PANEL_STATE: RunPanelState = Object.freeze({ element: null, actor: null, chat: "side", chatWidth: CHAT_DEFAULT_WIDTH, sheetExpandedHeight: null });
@@ -25,7 +25,7 @@ export const DEFAULT_RUN_PANEL_STATE: RunPanelState = Object.freeze({ element: n
 export const runPanelStorageKey = (runId: string) => `ragents.orchestration.run-panel:${runId}`;
 
 const isTextOrNull = (value: unknown): value is string | null => value === null || typeof value === "string";
-/** Frühere Zustände kannten `auto`, `floating` und `docked` sowie eine Bühnenhöhe; sie werden auf die heutigen Lagen abgebildet. */
+/** Earlier states knew `auto`, `floating` and `docked` as well as a stage height; they are mapped to today's positions. */
 const chatModeOf = (value: unknown): RunPanelChatMode | undefined =>
   value === undefined || value === "side" || value === "auto" ? "side"
     : value === "chat" ? "chat"
@@ -42,13 +42,13 @@ export function parseRunPanelState(raw: string | null): RunPanelState {
     || ("chatWidth" in value && (typeof value.chatWidth !== "number" || !Number.isFinite(value.chatWidth) || value.chatWidth < CHAT_MIN_WIDTH))
     || ("sheetExpandedHeight" in value && value.sheetExpandedHeight !== null && (typeof value.sheetExpandedHeight !== "number" || !Number.isFinite(value.sheetExpandedHeight) || value.sheetExpandedHeight <= 0))
     || ("sheetPeekExtra" in value && (typeof value.sheetPeekExtra !== "number" || !Number.isFinite(value.sheetPeekExtra) || value.sheetPeekExtra < 0))) {
-    throw new Error("Der gespeicherte Panelzustand ist ungültig.");
+    throw new Error("The stored panel state is invalid.");
   }
   const stored = value as { element: string | null; actor: string | null; chat?: unknown; chatWidth?: number; sheetExpandedHeight?: number | null };
   return { element: stored.element, actor: stored.actor, chat: chatModeOf(stored.chat) ?? "side", chatWidth: stored.chatWidth ?? CHAT_DEFAULT_WIDTH, sheetExpandedHeight: stored.sheetExpandedHeight ?? null };
 }
 
-/** Ohne Mini-App und in der Ansicht "Nur Chat" füllt der Chat das Run-Panel; sonst liegt er rechts, wenn Platz ist, und unten, wenn nicht. */
+/** Without a mini-app and in the "Chat only" view the chat fills the run panel; otherwise it sits on the right if there is room, and at the bottom if not. */
 export const chatLayoutFor = ({ chat, hasElement, narrow }: { chat: RunPanelChatMode; hasElement: boolean; narrow: boolean }): ChatLayout =>
   !hasElement || chat === "chat" ? "full" : !narrow && chat === "side" ? "side" : "floating";
 

package/plugins/ragents.orchestration/web/run-panel/sheet-status.ts

@@ -1,6 +1,6 @@
 import type { Message } from "quassel/events";
 
-/** Die eine Zeile des zugeschobenen Sheets: was der Chat gerade tut oder zuletzt gesagt hat. */
+/** The single line of the collapsed sheet: what the chat is doing right now or said last; open actions themselves are in the dock below. */
 export interface SheetStatus {
   text: string;
   kind: "idle" | "working" | "waiting";
@@ -8,23 +8,23 @@ export interface SheetStatus {
 
 const firstLine = (text: string, limit = 160): string => {
   const line = text.trim().split(/\r?\n/).find((entry) => entry.trim() !== "") ?? "";
-  return line.length > limit ? `${line.slice(0, limit - 1)}…` : line;
+  return line.length > limit ? `${line.slice(0, limit - 3)}...` : line;
 };
 
 const senderOf = (message: Message, handle: string): string =>
-  message.role === "user" ? "Du" : message.sender ?? `@${handle}`;
+  message.role === "user" ? "You" : message.sender ?? `@${handle}`;
 
 export function sheetStatus(messages: readonly Message[], working: boolean, handle: string): SheetStatus {
   const last = messages[messages.length - 1];
-  const waiting = [...messages].reverse().find((message) => message.role === "action" && message.action?.status === undefined);
-  if (waiting) return { kind: "waiting", text: `Wartet auf Eingabe: ${firstLine(waiting.text) || "Antwort erwartet"}` };
+  const waiting = messages.filter((message) => message.role === "action" && message.action?.status === undefined).length;
+  if (waiting > 0) return { kind: "waiting", text: waiting === 1 ? "Waiting for input" : `Waiting for ${waiting} inputs` };
   if (working) {
-    if (last?.role === "thinking" && !last.closed) return { kind: "working", text: `@${handle} denkt ...` };
-    if (last?.role === "tool" && last.tool && last.tool.result === undefined) return { kind: "working", text: `@${handle} nutzt ${last.tool.name} ...` };
-    if (last?.role === "assistant" && !last.closed && last.text.trim() !== "") return { kind: "working", text: `${senderOf(last, handle)} antwortet: ${firstLine(last.text)}` };
-    return { kind: "working", text: `@${handle} arbeitet ...` };
+    if (last?.role === "thinking" && !last.closed) return { kind: "working", text: `@${handle} is thinking ...` };
+    if (last?.role === "tool" && last.tool && last.tool.result === undefined) return { kind: "working", text: `@${handle} is using ${last.tool.name} ...` };
+    if (last?.role === "assistant" && !last.closed && last.text.trim() !== "") return { kind: "working", text: `${senderOf(last, handle)} is answering: ${firstLine(last.text)}` };
+    return { kind: "working", text: `@${handle} is working ...` };
   }
   const spoken = [...messages].reverse().find((message) => (message.role === "user" || message.role === "assistant") && message.text.trim() !== "");
-  if (!spoken) return { kind: "idle", text: "Noch keine Nachrichten." };
+  if (!spoken) return { kind: "idle", text: "No messages yet." };
   return { kind: "idle", text: `${senderOf(spoken, handle)}: ${firstLine(spoken.text)}` };
 }

package/plugins/ragents.orchestration/web/surface-startup.ts

@@ -11,23 +11,23 @@ export function surfaceStartupState({ view, startup, connected, running, error }
   running: boolean;
   error: string | undefined;
 }): SurfaceStartupState | undefined {
-  if (startup?.status === "failed") return { kind: "error", title: "Der Run konnte nicht vorbereitet werden", detail: startup.message };
-  if (error) return { kind: "error", title: "Der Run-Status ist nicht erreichbar", detail: error };
-  if (startup?.status === "preparing") return { kind: "working", title: "Run wird vorbereitet", detail: startup.message };
+  if (startup?.status === "failed") return { kind: "error", title: "The run could not be prepared", detail: startup.message };
+  if (error) return { kind: "error", title: "The run status is unreachable", detail: error };
+  if (startup?.status === "preparing") return { kind: "working", title: "Preparing run", detail: startup.message };
   const actors = view?.actors.filter((actor) => actor.kind !== "human") ?? [];
   const activeActors = actors.filter((actor) => actor.lifecycle?.kind !== "stopped");
-  if (actors.length && !activeActors.length) return { kind: "stopped", title: "Der Run wurde gestoppt", detail: "Es wird keine weitere Arbeit ausgeführt." };
+  if (actors.length && !activeActors.length) return { kind: "stopped", title: "The run was stopped", detail: "No further work is performed." };
   if (view?.actions.some((action) => action.status === "pending")) return {
-    kind: "waiting", title: "Deine Eingabe wird benötigt", detail: "Im Chat wartet eine Aktion auf Deine Eingabe.",
+    kind: "waiting", title: "Your input is needed", detail: "An action in the chat is waiting for your input.",
   };
   const activeIds = new Set(activeActors.map((actor) => actor.id));
   const working = running || activeActors.some((actor) => actor.lifecycle?.kind === "running")
     || view?.turns.some((turn) => activeIds.has(turn.actorId) && turn.status === "running")
     || view?.inputs.some((input) => activeIds.has(input.actorId) && isPendingRunActorInput(input));
-  if (working) return { kind: "working", title: "Der Run wird eingerichtet", detail: "Die Oberfläche wird aufgebaut. Die Elemente erscheinen automatisch." };
+  if (working) return { kind: "working", title: "Setting up the run", detail: "The interface is being built. The elements appear automatically." };
   const failed = activeActors.map((actor) => view?.turns.filter((turn) => turn.actorId === actor.id).at(-1))
     .find((turn) => turn?.status === "failed" || turn?.status === "interrupted");
-  if (failed) return { kind: "error", title: "Der Aufbau wurde angehalten", detail: failed.reason || "Der letzte Arbeitsschritt konnte nicht abgeschlossen werden." };
-  if (!connected) return { kind: "working", title: "Run wird geladen", detail: "Die Verbindung zum Run wird hergestellt." };
+  if (failed) return { kind: "error", title: "The setup was halted", detail: failed.reason || "The last work step could not be completed." };
+  if (!connected) return { kind: "working", title: "Loading run", detail: "Connecting to the run." };
   return undefined;
 }

package/plugins/ragents.orchestration/web/surface-view-settings.ts

@@ -15,7 +15,7 @@ export function parseSurfaceViewPreferences(raw: string | null): SurfaceViewPref
     || Object.keys(value).some((key) => key !== "actorVisibility")
     || !("actorVisibility" in value) || !value.actorVisibility || typeof value.actorVisibility !== "object"
     || Array.isArray(value.actorVisibility) || Object.values(value.actorVisibility).some((visible) => typeof visible !== "boolean")) {
-    throw new Error("Die gespeicherte Actor-Sichtbarkeit ist ungültig.");
+    throw new Error("The stored actor visibility is invalid.");
   }
   return value as SurfaceViewPreferences;
 }

package/plugins/ragents.orchestration/web/tiled-view-settings.ts

@@ -17,7 +17,7 @@ export function parseSurfacePresentation(raw: string | null): SurfacePresentatio
   if (!value || typeof value !== "object" || Array.isArray(value)
     || !("root" in value) || Object.keys(value).some((key) => !["root", "programBasis"].includes(key))
     || ("programBasis" in value && typeof value.programBasis !== "string")) {
-    throw new Error("Die gespeicherte Kachelansicht ist ungültig.");
+    throw new Error("The stored tile view is invalid.");
   }
   return { root: value.root === null ? null : surfaceTileNodeOf(value.root),
     ...("programBasis" in value ? { programBasis: value.programBasis as string } : {}),

package/plugins/ragents.overseer/contract.ts

@@ -12,8 +12,8 @@ export interface QuickAnswerState {
 }
 
 export const overseerPermissions = [
-  { id: "ragents.overseer.read", description: "Den globalen Koordinator und seine Modellauswahl ansehen." },
-  { id: "ragents.overseer.write", description: "Dem globalen Koordinator Aufträge geben und sein Gespräch zurücksetzen." },
+  { id: "ragents.overseer.read", description: "View the global coordinator and its model selection." },
+  { id: "ragents.overseer.write", description: "Give tasks to the global coordinator and reset its conversation." },
 ] as const;
 
 export interface OverseerModelSelection {
@@ -31,7 +31,7 @@ const text = () => Type.String({ minLength: 1, pattern: "\\S" });
 const empty = object({});
 const jsonObject = Type.Record(Type.String(), Type.Any());
 const eventType = Type.Unsafe<EventType>(Type.Union(Object.keys(eventTypeMap).map((name) => Type.Literal(name))));
-const run = Type.String({ minLength: 1, maxLength: 512, description: "Run-ID, eindeutiger Titel oder stabile Referenz wie Run 1." });
+const run = Type.String({ minLength: 1, maxLength: 512, description: "Run ID, unique title or stable reference such as Run 1." });
 const identityFields = { runId: Type.String(), title: Type.String(), reference: Type.String() };
 const runSummary = object({ ...identityFields, createdAt: Type.Optional(Type.Number()), updatedAt: Type.Number(), running: Type.Optional(Type.Boolean()), metadata: Type.Optional(jsonObject) });
 const accepted = object({ ...identityFields, accepted: Type.Literal(true) });
@@ -39,11 +39,11 @@ const commonStart = { title: text(), options: Type.Optional(jsonObject) };
 const createInput = Type.Union([
   object({ ...commonStart, message: text() }),
   object({ ...commonStart, script: text(), input: Type.Optional(Type.Any()) }),
-  object({ ...commonStart, packageDirectory: Type.String({ minLength: 1, description: "Absoluter Pfad eines RUN.md/setup.ts/tests.json-Pakets auf dem Server. Ein lokaler Shellclient setzt seinen tatsächlich vorhandenen Paketpfad ein; dies ist kein Upload." }), input: Type.Optional(Type.Any()) }),
+  object({ ...commonStart, packageDirectory: Type.String({ minLength: 1, description: "Absolute path of a RUN.md/setup.ts/tests.json package on the server. A local shell client inserts its actually existing package path; this is not an upload." }), input: Type.Optional(Type.Any()) }),
 ]);
 const domainObject = (name: string, source = "packages/ragents/src/domain/model.ts") => Type.Object({}, {
   additionalProperties: true, "x-typescript-type": name, "x-source": source,
-  description: `Ungekürzter Domänenwert ${name}; verschachtelte Felder sind hier bewusst ein offenes JSON-Schema.`,
+  description: `Unabridged domain value ${name}; nested fields are deliberately an open JSON schema here.`,
 });
 const eventSchema = object({
   eventId: Type.String(), runId: Type.String(), sequence: Type.Integer({ minimum: 1 }), schemaVersion: Type.Literal(3),
@@ -65,32 +65,32 @@ const settingsResult = object({
   models: Type.Array(object({ id: Type.String(), provider: Type.String(), label: Type.String(), thinking: Type.Array(Type.String()) })),
 });
 
-/** Die Verwaltung der Runs, die Modellauswahl und der Gesprächsreset des globalen Koordinators. */
+/** Run management, model selection and conversation reset of the global coordinator. */
 export const overseerContracts = {
   listRuns: defineOperation({
     id: "ragents.overseer.listRuns",
-    description: "Die Runs, die der Aufrufer sieht, mit stabilen Referenzen auflisten; die globalen Koordinatoren gehören nicht zu dieser Liste.",
+    description: "List the runs the caller sees, with stable references; the global coordinators are not part of this list.",
     rights: ["runs.read"],
     input: empty,
     result: Type.Array(runSummary),
   }),
   createRun: defineOperation({
     id: "ragents.overseer.createRun",
-    description: "Einen Run mit serverseitiger ID und Titel anlegen. Genau eine Startform: message, installiertes script (Kennung oder eindeutiger Titel), oder packageDirectory (vorhandenes lokales Run-Script-Paket). input ist nur bei script/packageDirectory erlaubt. options wählt Startoptionen wie ragents.startOptions.select, jede nur mit ihren eigenen Rechten. Das Ergebnis wartet auf Vorbereitung, Check, Test und Installation; accepted bestätigt noch kein fertiges Modellergebnis.",
+    description: "Create a run with a server-side ID and title. Exactly one start form: message, installed script (id or unique title), or packageDirectory (existing local run script package). input is only allowed with script/packageDirectory. options selects start options such as ragents.startOptions.select, each only with its own rights. The result waits for preparation, check, test and installation; accepted does not yet confirm a finished model result.",
     rights: ["runs.read", "runs.write", "runs.create"],
     input: createInput,
     result: accepted,
   }),
   readRun: defineOperation({
     id: "ragents.overseer.readRun",
-    description: "Die aktuelle ungekürzte RunView lesen; verschachtelte Domänenwerte sind als offene JSON-Objekte dokumentiert.",
+    description: "Read the current unabridged RunView; nested domain values are documented as open JSON objects.",
     rights: ["runs.read", "runs.inspect"],
     input: object({ run }),
     result: viewSchema,
   }),
   readEvents: defineOperation({
     id: "ragents.overseer.readEvents",
-    description: "Das vollständige Journal seitenweise in Sequenzreihenfolge lesen. Solange hasMore wahr ist, nextAfter als after der nächsten Anfrage verwenden. type filtert einen exakten Ereignistyp.",
+    description: "Read the complete journal page by page in sequence order. As long as hasMore is true, use nextAfter as after of the next request. type filters an exact event type.",
     rights: ["runs.read", "runs.inspect"],
     input: object({
       run,
@@ -102,21 +102,21 @@ export const overseerContracts = {
   }),
   sendMessage: defineOperation({
     id: "ragents.overseer.sendMessage",
-    description: "Eine Chatnachricht an den primären LLM-Actor einreihen; TypeScript als Primary wird mit actor-chat-unsupported abgewiesen. Das Ergebnis bestätigt nur das Einreihen, weder Verarbeitung noch Abschluss. Ein laufender Turn wird dadurch nicht ersetzt.",
+    description: "Enqueue a chat message for the primary LLM actor; TypeScript as primary is rejected with actor-chat-unsupported. The result only confirms the enqueueing, neither processing nor completion. A running turn is not replaced by it.",
     rights: ["runs.read", "runs.write"],
     input: object({ run, message: text() }),
     result: accepted,
   }),
   stopRun: defineOperation({
     id: "ragents.overseer.stopRun",
-    description: "Den Run über seine normale Stoppgrenze stoppen und die Bereinigung abwarten; das Gespräch bleibt erhalten.",
+    description: "Stop the run through its normal stop boundary and wait for the cleanup; the conversation is kept.",
     rights: ["runs.read", "runs.write"],
     input: object({ run }),
     result: object({ ...identityFields, stopped: Type.Literal(true) }),
   }),
   readCatalog: defineOperation({
     id: "ragents.overseer.readCatalog",
-    description: "Installierte Vorlagen und Startoptionen mit Eingabeschemata, Standardwerten und Wählbarkeit lesen. createRun startet Nachrichten, installierte Scripts oder lokale Pakete via packageDirectory. Skills liefern bearbeitbare Aufträge für message; dabei den Skillnamen als Arbeitsanleitung nennen.",
+    description: "Read installed templates and start options with input schemas, default values and selectability. createRun starts messages, installed scripts or local packages via packageDirectory. Skills provide editable tasks for message; name the skill as the work instruction.",
     rights: ["runs.read", "runs.inspect"],
     input: empty,
     result: object({
@@ -126,14 +126,14 @@ export const overseerContracts = {
   }),
   readReference: defineOperation({
     id: "ragents.overseer.readReference",
-    description: "Lesbare Referenz aller registrierten Methoden und Kanäle direkt aus ihren Verträgen lesen.",
+    description: "Read a readable reference of all registered methods and channels directly from their contracts.",
     rights: ["runs.read", "runs.inspect"],
     input: empty,
     result: Type.String(),
   }),
   readOpenRpc: defineOperation({
     id: "ragents.overseer.readOpenRpc",
-    description: "OpenRPC 1.3 direkt aus denselben Verträgen lesen.",
+    description: "Read OpenRPC 1.3 directly from the same contracts.",
     rights: ["runs.read", "runs.inspect"],
     input: empty,
     result: jsonObject,
@@ -141,14 +141,14 @@ export const overseerContracts = {
   settings: {
     read: defineOperation({
       id: "ragents.overseer.settings.read",
-      description: "Die Modellauswahl des globalen Koordinators mit dem verfügbaren Modellkatalog lesen.",
+      description: "Read the global coordinator's model selection with the available model catalog.",
       rights: ["ragents.overseer.read"],
       input: empty,
       result: settingsResult,
     }),
     save: defineOperation({
       id: "ragents.overseer.settings.save",
-      description: "Die Modellauswahl des globalen Koordinators setzen; sie gilt ab der nächsten Antwort.",
+      description: "Set the global coordinator's model selection; it applies from the next answer on.",
       rights: ["ragents.overseer.read", "ragents.overseer.write", "settings.write"],
       input: modelSelection,
       result: settingsResult,
@@ -156,16 +156,16 @@ export const overseerContracts = {
   },
   coordinator: defineOperation({
     id: "ragents.overseer.coordinator",
-    description: "Die Run-ID des eigenen globalen Koordinators lesen: je angemeldetem Benutzer einer, ohne Anmeldung genau einer.",
+    description: "Read the run ID of your own global coordinator: one per signed-in user, exactly one without sign-in.",
     rights: ["ragents.overseer.read"],
     input: empty,
     result: object({ runId: Type.String() }),
   }),
   reset: defineOperation({
     id: "ragents.overseer.reset",
-    description: "Das Gespräch des eigenen globalen Koordinators samt Modellkontext zurücksetzen; die Modellauswahl, die Koordinatoren anderer Benutzer und alle Runs bleiben erhalten.",
+    description: "Reset the conversation of your own global coordinator including its model context; the model selection, other users' coordinators and all runs are kept.",
     rights: ["ragents.overseer.read", "ragents.overseer.write"],
-    input: object({ confirm: Type.Literal(true, { description: "Der Gesprächsreset muss ausdrücklich bestätigt werden." }) }),
+    input: object({ confirm: Type.Literal(true, { description: "The conversation reset must be confirmed explicitly." }) }),
     result: Type.Null(),
   }),
 } as const;

package/plugins/ragents.overseer/server/api.ts

@@ -3,7 +3,7 @@ import type { Static } from "typebox";
 import { DomainError, implement, type AccessContext, type JsonValue, type MethodContribution, type PluginHost } from "@ragents/engine";
 import { methodReference, openRpcDocument, type ApiAuthentication } from "@ragents/host/api/reference.js";
 import type { RunManagement } from "@ragents/host/ragents/global-chat.js";
-import { overseerContracts } from "../contract.js";
+import { OVERSEER_PLUGIN_ID, overseerContracts } from "../contract.js";
 import { coordinatorRunIdOf } from "./coordinator.js";
 import type { RunDirectory } from "./run-directory.js";
 
@@ -18,7 +18,7 @@ type CreateInput = Static<typeof overseerContracts.createRun.input>;
 
 const identity = (found: { id: string; title: string; reference: string }) => ({ runId: found.id, title: found.title, reference: found.reference });
 
-/** Aufgelöst wird nur über die Runs des Aufrufers; ein fremder Run ist hier so unbekannt wie ein nicht vorhandener. */
+/** Resolution only covers the caller's runs; someone else's run is as unknown here as a nonexistent one. */
 const resolve = async (context: ManagementContext, access: AccessContext, reference: string) => {
   const runs = await context.management().list(access);
   const exact = runs.find((entry) => entry.id === reference);
@@ -35,21 +35,21 @@ const create = async (context: ManagementContext, body: CreateInput, access: Acc
   };
   const runId = await (async () => {
     if ("packageDirectory" in body) {
-      if (!path.isAbsolute(body.packageDirectory)) throw new DomainError("invalid-package-directory", "packageDirectory muss ein absoluter Serverpfad sein", 400);
-      return context.management().create({ ...common, kind: "package", directory: body.packageDirectory, input: (body.input ?? null) as JsonValue });
+      if (!path.isAbsolute(body.packageDirectory)) throw new DomainError("invalid-package-directory", "packageDirectory must be an absolute server path", 400);
+      return context.management().create({ ...common, kind: "package", directory: body.packageDirectory, input: (body.input ?? null) as JsonValue, owner: OVERSEER_PLUGIN_ID });
     }
     if ("script" in body) {
       const entries = context.root.startEntries.describe().filter((entry) => entry.action === "script");
-      const wanted = body.script.trim().toLocaleLowerCase("de");
+      const wanted = body.script.trim().toLocaleLowerCase("en-US");
       const direct = entries.find((entry) => entry.id === body.script.trim());
-      const matching = direct ? [direct] : entries.filter((entry) => entry.title.toLocaleLowerCase("de") === wanted);
-      if (matching.length !== 1) throw new DomainError("invalid-script", `Das Run-Script ist unbekannt oder mehrdeutig. Gültige Titel und Kennungen: ${entries.map((entry) => `${entry.title} (${entry.id})`).join(", ") || "keine"}`, 400);
+      const matching = direct ? [direct] : entries.filter((entry) => entry.title.toLocaleLowerCase("en-US") === wanted);
+      if (matching.length !== 1) throw new DomainError("invalid-script", `The run script is unknown or ambiguous. Valid titles and ids: ${entries.map((entry) => `${entry.title} (${entry.id})`).join(", ") || "none"}`, 400);
       return context.management().create({ ...common, kind: "script", entryId: matching[0].id, input: (body.input ?? null) as JsonValue });
     }
     return context.management().create({ ...common, kind: "message", message: body.message.trim() });
   })();
   const found = (await context.directory.describe(await context.management().list())).find((entry) => entry.id === runId);
-  if (!found) throw new DomainError("run-unavailable", "Der erstellte Run ist nicht mehr verfügbar", 409);
+  if (!found) throw new DomainError("run-unavailable", "The created run is no longer available", 409);
   return { ...identity(found), accepted: true as const };
 };
 

package/plugins/ragents.overseer/server/coordinator-prompt.ts

@@ -1,13 +1,13 @@
-export const coordinatorPrompt = `Du koordinierst Aufträge in RAgents.
-Neue Runs dürfen mit einem fachlichen Auftrag starten. Der Auftrag beschreibt das gewünschte Ergebnis; der Run-Koordinator entdeckt die Funktionen und wählt seine technische Umsetzung selbst.
-Prüfe bei vorhandenen Runs den Typ des Primary-Actors in der Run-Ansicht. Ein TypeScript-Actor ist ein Programm mit festem Eingabeprotokoll, kein Chatpartner. Die Nachrichtenroute akzeptiert nur LLM-Actors; verwende bei Programmen die dokumentierte Mini-App oder Funktionen. Eine erfolgreiche Nachrichtenannahme bestätigt nur das Einreihen und beweist keine Ausführung. Behaupte einen Neustart oder eine Erledigung erst bei entsprechendem Ergebnis.
-Die Fläche eines Runs besteht aus Kacheln. Benutzer können eine bestimmte Aufteilung verlangen, etwa Mini-App links und Chat rechts 50:50 oder eine Kachel oben und zwei unten im Verhältnis 2:1. Übernimm diese Wünsche in den Run-Auftrag; der Run setzt sie über context.functions.canvas_layout_replace mit verschachteltem root um. Bei bestehenden Runs gib den Layoutauftrag an den LLM-Koordinator weiter. Persönliche Benutzeranordnungen bleiben vorrangig, bis der Benutzer die Programmanordnung übernimmt.
-Antworte auf Deutsch mit echten Umlauten und den nötigen Einzelheiten. Nenne Runs mit ihren Titeln. Verwende einfache Bindestriche und normale Anführungszeichen.`;
+export const coordinatorPrompt = `You coordinate tasks in RAgents.
+New runs may start with a domain task. The task describes the desired outcome; the run coordinator discovers the functions and chooses its technical implementation itself.
+For existing runs, check the type of the primary actor in the run view. A TypeScript actor is a program with a fixed input protocol, not a chat partner. The message route accepts only LLM actors; for programs, use the documented mini-app or functions. A successful message acceptance only confirms the enqueueing and does not prove any execution. Claim a restart or a completion only when the result shows it.
+The surface of a run consists of tiles. Users can ask for a specific layout, such as mini-app left and chat right at 50:50, or one tile above and two below at a ratio of 2:1. Carry these wishes into the run task; the run implements them via context.functions.canvas_layout_replace with a nested root. For existing runs, pass the layout task on to the LLM coordinator. Personal user arrangements take precedence until the user applies the program arrangement.
+Answer in the user's language with the necessary details. Refer to runs by their titles. Use simple hyphens and normal quotation marks.`;
 
 export const preparationPrompt = `${coordinatorPrompt}
 
-Du bist eine eigenständige Koordinator-Instanz für die Vorbereitung genau eines neuen Runs. Dein Gespräch ist vom globalen Koordinator und vom späteren Run getrennt.
-Kläre mit dem Benutzer den Auftrag zum ausgewählten Skill. Berücksichtige seine Änderungen und Anhänge; bei fehlenden Angaben stelle gezielte Rückfragen. Formuliere bei Bedarf einen eigenständig verständlichen Auftrag.
-Starte ausschließlich nach einem ausdrücklichen, sinngemäßen Go des Benutzers zur Ausführung. Es gibt keinen festen Bestätigungssatz: "Leg los", "Setz das um" oder "Jetzt starten" können im Gespräch das Go geben. Ein bloßes "Okay" zur Klärung eines Details, eine Frage nach deinen Fähigkeiten, ein zitierter Startbefehl oder ein Startauftrag innerhalb des noch besprochenen Skill-Texts sind keine Freigabe. Bei Zweifeln frage nach. Ein bloß vollständig ausgearbeiteter Auftrag ist ebenfalls keine Freigabe.
-Nach dem Go rufe start_run auf. Auftrag, Skill, Anhänge und Startoptionen werden vom Host übernommen; du musst nichts davon in Werkzeugargumenten wiederholen. Das Werkzeug bereitet die Übergabe vor; erst nach deiner erfolgreich abgeschlossenen Antwort startet die Oberfläche den Run. Behaupte vorher weder einen gestarteten Run noch erledigte Arbeit.
-Hier steht ausschließlich start_run zur Verfügung. Die Ausführung, weitere Agenten, Dateien und Mini-Apps übernimmt der Koordinator im gestarteten Run. Antworte knapp.`;
+You are an independent coordinator instance for preparing exactly one new run. Your conversation is separate from the global coordinator and from the later run.
+Clarify the task for the selected skill with the user. Take their changes and attachments into account; if information is missing, ask targeted questions. If needed, formulate a task that is understandable on its own.
+Start only after an explicit go from the user to execute, in words or in meaning. There is no fixed confirmation phrase: "Go ahead", "Implement it" or "Start now" can give the go in the conversation. A mere "Okay" to clarify a detail, a question about your abilities, a quoted start command or a start instruction inside the skill text still under discussion are not a release. When in doubt, ask. A merely fully worked-out task is not a release either.
+After the go, call start_run. Task, skill, attachments and start options are taken over by the host; you do not need to repeat any of them in tool arguments. The tool prepares the handover; only after your successfully completed answer does the interface start the run. Before that, claim neither a started run nor completed work.
+Only start_run is available here. Execution, further agents, files and mini-apps are handled by the coordinator in the started run. Answer briefly.`;

package/plugins/ragents.overseer/server/coordinator.ts

@@ -2,18 +2,18 @@ import { createHash } from "node:crypto";
 import { DomainError, type AccessContext } from "@ragents/engine";
 
 const PREFIX = "overseer-";
-/** Die Kennung des früheren gemeinsamen Koordinators: bleibt reserviert, gehört aber keinem Zugang. */
+/** The id of the former shared coordinator: stays reserved but belongs to no access. */
 export const SHARED_OVERSEER_RUN_ID = "overseer";
 
-/** Der Koordinator eines Benutzers; ohne Anmeldung (null) gibt es genau einen. */
+/** A user's coordinator; without sign-in (null) there is exactly one. */
 export const coordinatorRunId = (userId: string | null): string =>
   userId === null ? `${PREFIX}single` : `${PREFIX}${createHash("sha256").update(userId).digest("hex").slice(0, 24)}`;
 
 export const isCoordinatorRunId = (runId: string): boolean => runId === SHARED_OVERSEER_RUN_ID || runId.startsWith(PREFIX);
 
-/** Der Koordinator des Aufrufers: ohne Anmeldung der eine, sonst der des angemeldeten Benutzers. */
+/** The caller's coordinator: without sign-in the single one, otherwise the signed-in user's. */
 export const coordinatorRunIdOf = (access: AccessContext): string => {
   if (!access.enabled) return coordinatorRunId(null);
-  if (!access.user) throw new DomainError("login-required", "Bitte melde dich an.", 401);
+  if (!access.user) throw new DomainError("login-required", "Please sign in.", 401);
   return coordinatorRunId(access.user.id);
 };