@schlenkr/ragents 0.1.9 → 0.1.11

package/plugins/ragents.todo/server/todo-tool.ts

@@ -18,7 +18,7 @@ export const todoToolMetadata = {
 
 export const canManageTodos = defineToolAvailability({
   availability: "conditional",
-  availabilityDetail: "Nur für Agenten mit der Capability plugin.state.write.",
+  availabilityDetail: "Only for agents with the capability plugin.state.write.",
 }, (actor) => actor.kind === "agent" && holdsUsable(actor, "plugin.state.write"));
 
 const checked = (todos: readonly { id: string; text: string; status: string }[]) => {
@@ -29,9 +29,9 @@ const checked = (todos: readonly { id: string; text: string; status: string }[])
     const text = todo.text.trim();
     const status = todoStatusOf(todo.status);
 
-    if (!id) throw new DomainError("invalid-todo", `todos[${index}].id ist leer.`, 400);
-    if (!text) throw new DomainError("invalid-todo", `todos[${index}].text ist leer.`, 400);
-    if (!status) throw new DomainError("invalid-todo", `todos[${index}].status ${todo.status} ist unbekannt.`, 400);
+    if (!id) throw new DomainError("invalid-todo", `todos[${index}].id is empty.`, 400);
+    if (!text) throw new DomainError("invalid-todo", `todos[${index}].text is empty.`, 400);
+    if (!status) throw new DomainError("invalid-todo", `todos[${index}].status ${todo.status} is unknown.`, 400);
     if (seen.has(id)) throw new DomainError("duplicate-todo-id", `To-do ID ${id} occurs more than once.`, 400);
 
     seen.add(id);
@@ -49,8 +49,8 @@ export const createTodoTool = (): RunFunction =>
           id: Type.String({ minLength: 1 }),
           text: Type.String({ minLength: 1 }),
           status: Type.Union(TODO_STATUS_INPUTS.map((value) => Type.Literal(value)), {
-            description: "open = offen, active = in Arbeit, completed = erledigt; "
-              + "pending, in_progress und done werden ebenfalls angenommen",
+            description: "open = not started, active = in progress, completed = done; "
+              + "pending, in_progress and done are accepted as well",
           }),
         }),
       ),

package/plugins/ragents.todo/web/TodoSection.tsx

@@ -33,7 +33,7 @@ export function TodoSection({ actor, session }: CardSectionContext) {
           </li>
         ))}
       </ul>
-      {todos.length > MAX_ITEMS && <small className="pl-0.5 text-xs text-muted-foreground">+{todos.length - MAX_ITEMS} weitere</small>}
+      {todos.length > MAX_ITEMS && <small className="pl-0.5 text-xs text-muted-foreground">+{todos.length - MAX_ITEMS} more</small>}
     </section>
   );
 }

package/plugins/ragents.transcript/server/transcript.ts

@@ -14,16 +14,16 @@ const compactJson = (value: unknown, limit: number): string => collapse(typeof v
 const lineOf = (event: JournalEvent, actorId: string): string | undefined => {
   if (event.type === "actor.input.enqueued") {
     if (event.payload.actorId !== actorId) return undefined;
-    return event.payload.content === undefined ? `> [Ereignis ${event.payload.sourceEventIds[0]}]` : `> ${collapse(event.payload.content, 1000)}`;
+    return event.payload.content === undefined ? `> [Event ${event.payload.sourceEventIds[0]}]` : `> ${collapse(event.payload.content, 1000)}`;
   }
   if (event.actorId !== actorId) return undefined;
   switch (event.type) {
     case "model.output.completed": return event.payload.text.trim() ? collapse(event.payload.text, 4000) : undefined;
     case "tool.call.started": return `[${event.payload.name}] ${compactJson(event.payload.input, 200)}`;
     case "tool.call.completed": return `  -> ${compactJson(event.payload.output, 300)}`;
-    case "tool.call.failed": return `  -> Fehler: ${collapse(event.payload.error, 300)}`;
-    case "turn.finished": return event.payload.outcome === "failed" ? `[Turn fehlgeschlagen: ${collapse(event.payload.reason, 300)}]` : undefined;
-    case "turn.interrupted": return `[Turn unterbrochen: ${collapse(event.payload.reason, 300)}]`;
+    case "tool.call.failed": return `  -> Error: ${collapse(event.payload.error, 300)}`;
+    case "turn.finished": return event.payload.outcome === "failed" ? `[Turn failed: ${collapse(event.payload.reason, 300)}]` : undefined;
+    case "turn.interrupted": return `[Turn interrupted: ${collapse(event.payload.reason, 300)}]`;
     default: return undefined;
   }
 };
@@ -39,26 +39,26 @@ export function compactTranscript(events: readonly JournalEvent[], actorId: stri
     dropped += 1;
   }
   const kept = lines.slice(dropped);
-  return { text: [`[... ${dropped} frühere Zeilen ausgelassen]`, ...kept].join("\n"), lines: kept.length, truncated: true };
+  return { text: [`[... ${dropped} earlier lines omitted]`, ...kept].join("\n"), lines: kept.length, truncated: true };
 }
 
 export const transcriptToolMetadata = {
   name: "actor_transcript",
-  label: "Verlauf verdichten",
-  description: "Liefert den Verlauf eines Actors dieses Runs als kompaktes Transkript: Eingaben, Antworttexte und Werkzeugaufrufe je eine Zeile, Ergebnisse gekürzt, ohne Reasoning. Für Übergaben, Statusberichte und Zusammenfassungen.",
+  label: "Compact history",
+  description: "Returns the history of an actor of this run as a compact transcript: inputs, answer texts and tool calls one line each, results shortened, without reasoning. For handovers, status reports and summaries.",
 } as const;
 
 export const canReadTranscripts = defineToolAvailability({
   availability: "conditional",
-  availabilityDetail: "Für Agenten und Skript-Actors mit der Capability event.subscribe.",
+  availabilityDetail: "For agents and script actors with the capability event.subscribe.",
 }, (actor) => actor.kind !== "human" && holdsUsable(actor, "event.subscribe"));
 
 export const createTranscriptTool = (runtime: () => Orchestration): RunFunction =>
   defineRunFunction({
     ...transcriptToolMetadata,
     schema: Type.Object({
-      actor: Type.String({ minLength: 1, description: "Handle mit oder ohne @ oder ID eines Actors dieses Runs" }),
-      maxChars: Type.Optional(Type.Integer({ minimum: 200, maximum: 200_000, description: `Obergrenze in Zeichen, Standard ${defaultMaxChars}; die ältesten Zeilen entfallen zuerst` })),
+      actor: Type.String({ minLength: 1, description: "Handle with or without @, or ID of an actor of this run" }),
+      maxChars: Type.Optional(Type.Integer({ minimum: 200, maximum: 200_000, description: `Upper limit in characters, default ${defaultMaxChars}; the oldest lines are dropped first` })),
     }, { additionalProperties: false }),
     resultSchema: Type.Object({
       actorId: Type.String(),
@@ -71,7 +71,7 @@ export const createTranscriptTool = (runtime: () => Orchestration): RunFunction
     run: ({ caller }, _toolCallId, input) => {
       const view = runtime().view(caller.runId);
       const actor = actorByReference(view.actors, input.actor);
-      if (!actor) throw new Error(`Unbekannter Actor in diesem Run: ${input.actor}`);
+      if (!actor) throw new Error(`Unknown actor in this run: ${input.actor}`);
       return { actorId: actor.id, handle: actor.handle, ...compactTranscript(runtime().events(caller.runId), actor.id, input.maxChars) };
     },
   });

package/plugins/ragents.watch/server/condition.ts

@@ -32,17 +32,17 @@ export class WatchConditionError extends Error {
 }
 
 export const compileWatchCondition = async (condition: string, signal?: AbortSignal): Promise<WatchPredicate> => {
-  if (!condition.trim()) throw new WatchConditionError("Die Weckbedingung darf nicht leer sein.");
+  if (!condition.trim()) throw new WatchConditionError("The wake condition must not be empty.");
   const compiled = await compileVirtualTypeScriptAsync({
     sources: [{ fileName: conditionFile, text: `${watchStateDeclarations}\nconst wake = (now: WatchState, before: WatchState): string | undefined => {\n${condition}\n};\n` }],
     emit: "node",
   }, { signal });
   if (!compiled.valid) {
-    throw new WatchConditionError(`Die Weckbedingung ist kein gültiges TypeScript:\n${compiled.diagnostics.map((diagnostic) =>
+    throw new WatchConditionError(`The wake condition is not valid TypeScript:\n${compiled.diagnostics.map((diagnostic) =>
       `${diagnostic.start ? `${Math.max(1, diagnostic.start.line - watchStateDeclarations.split("\n").length)}:${diagnostic.start.column} ` : ""}TS${diagnostic.code}: ${diagnostic.message}`).join("\n")}`);
   }
   const emitted = compiled.emittedFiles.find((file) => file.fileName.endsWith(".js"));
-  if (!emitted) throw new WatchConditionError("Die Weckbedingung hat keinen JavaScript-Code erzeugt.");
+  if (!emitted) throw new WatchConditionError("The wake condition produced no JavaScript code.");
   const sandbox = createContext(Object.create(null));
   runInContext(`${emitted.text}\nglobalThis.wake = wake;`, sandbox, { timeout: RUN_TIMEOUT_MS });
   return (now, before) => {
@@ -50,7 +50,7 @@ export const compileWatchCondition = async (condition: string, signal?: AbortSig
     sandbox.before = before;
     const result: unknown = runInContext("wake(now, before)", sandbox, { timeout: RUN_TIMEOUT_MS });
     if (result === undefined || result === null || result === false) return undefined;
-    if (typeof result !== "string" || !result.trim()) throw new WatchConditionError(`Die Weckbedingung muss einen Grund als Text oder nichts liefern, nicht ${JSON.stringify(result)}.`);
+    if (typeof result !== "string" || !result.trim()) throw new WatchConditionError(`The wake condition must return a reason as text or nothing, not ${JSON.stringify(result)}.`);
     return result.trim().slice(0, REASON_CHARS);
   };
 };

package/plugins/ragents.watch/server/functions.ts

@@ -3,56 +3,56 @@ import { defineRunFunction, defineToolAvailability, type ToolContributor } from
 import { toolDescriptorFrom } from "@ragents/host/plugin-support/agent-tool.js";
 import type { WatchServiceApi } from "../contract.js";
 
-const available = defineToolAvailability({ availability: "always", availabilityDetail: "In jedem Run verfügbar." }, () => true);
+const available = defineToolAvailability({ availability: "always", availabilityDetail: "Available in every run." }, () => true);
 
 const verdictSchema = Type.Object({
-  at: Type.String({ description: "Zeitpunkt der Bewertung" }),
-  wake: Type.Boolean({ description: "Ob der Wächter geweckt hat" }),
-  reason: Type.String({ description: "Grund, den die Bedingung geliefert hat, oder 'Bedingung nicht erfüllt'" }),
-  changes: Type.Array(Type.String(), { description: "Änderungen seit der letzten Weckung, die der Bewertung vorlagen" }),
+  at: Type.String({ description: "Time of the evaluation" }),
+  wake: Type.Boolean({ description: "Whether the watch woke" }),
+  reason: Type.String({ description: "Reason the condition returned, or 'Condition not met'" }),
+  changes: Type.Array(Type.String(), { description: "Changes since the last wake that the evaluation saw" }),
 }, { additionalProperties: false });
 
 const summarySchema = Type.Object({
-  id: Type.String({ description: "Kennung des Wächters für watch_remove" }),
-  source: Type.String({ description: "Beobachteter Actor als @handle" }),
-  target: Type.String({ description: "Geweckter Actor als @handle" }),
-  condition: Type.String({ description: "Weckbedingung als TypeScript-Funktionsrumpf" }),
-  observe: Type.Optional(Type.String({ description: "Benannte Operation, deren Ergebnis zum beobachteten Stand gehört" })),
-  stallAfterSeconds: Type.Optional(Type.Integer({ description: "Sekunden ohne Ereignis des beobachteten Actors, ab denen der Stand einen Stillstand nennt" })),
-  wakes: Type.Integer({ description: "Anzahl der bisherigen Weckungen" }),
-  lastEvaluatedAt: Type.Optional(Type.String({ description: "Zeitpunkt der letzten Bewertung" })),
+  id: Type.String({ description: "Id of the watch for watch_remove" }),
+  source: Type.String({ description: "Observed actor as @handle" }),
+  target: Type.String({ description: "Woken actor as @handle" }),
+  condition: Type.String({ description: "Wake condition as a TypeScript function body" }),
+  observe: Type.Optional(Type.String({ description: "Named operation whose result belongs to the observed state" })),
+  stallAfterSeconds: Type.Optional(Type.Integer({ description: "Seconds without an event of the observed actor after which the state reports a stall" })),
+  wakes: Type.Integer({ description: "Number of wakes so far" }),
+  lastEvaluatedAt: Type.Optional(Type.String({ description: "Time of the last evaluation" })),
   lastVerdict: Type.Optional(verdictSchema),
 }, { additionalProperties: false });
 
 const createSchema = Type.Object({
-  source: Type.String({ minLength: 1, description: "Beobachteter Actor als @handle oder Kennung" }),
-  condition: Type.String({ minLength: 1, maxLength: 4_000, description: "Weckbedingung als TypeScript-Funktionsrumpf von (now: WatchState, before: WatchState) => string | undefined; liefert den Weckgrund als Text oder undefined. WatchState: source { lifecycle idle|running|stopped, completedTurns, lastTurn { status, reason? }, pendingInputs, pendingActions, lastOutput? }, observed (Ergebnis der observe-Operation als Record<string, unknown>), stalledForSeconds (nur bei Stillstand). before ist der Stand bei der letzten Weckung. Beispiel: return now.source.completedTurns > before.source.completedTurns && now.observed?.phase !== \"ready\" ? \"Turn beendet, Auftrag nicht fertig\" : undefined;" }),
-  target: Type.Optional(Type.String({ minLength: 1, description: "Zu weckender Actor als @handle oder Kennung; ohne Angabe der Aufrufer" })),
-  observe: Type.Optional(Type.String({ minLength: 1, description: "Benannte Operation ohne Eingabe, deren Ergebnis den beobachteten Stand ergänzt und per Differenz verglichen wird" })),
-  instruction: Type.Optional(Type.String({ minLength: 1, maxLength: 2_000, description: "Text, der jeder Weckung angehängt wird, etwa wie der Geweckte reagieren soll" })),
-  stallAfterSeconds: Type.Optional(Type.Integer({ minimum: 1, description: "Sekunden ohne Ereignis des beobachteten Actors, ab denen der Stand stalledForSeconds nennt" })),
+  source: Type.String({ minLength: 1, description: "Observed actor as @handle or id" }),
+  condition: Type.String({ minLength: 1, maxLength: 4_000, description: "Wake condition as a TypeScript function body of (now: WatchState, before: WatchState) => string | undefined; returns the wake reason as text or undefined. WatchState: source { lifecycle idle|running|stopped, completedTurns, lastTurn { status, reason? }, pendingInputs, pendingActions, lastOutput? }, observed (result of the observe operation as Record<string, unknown>), stalledForSeconds (only when stalled). before is the state at the last wake. Example: return now.source.completedTurns > before.source.completedTurns && now.observed?.phase !== \"ready\" ? \"Turn ended, task not finished\" : undefined;" }),
+  target: Type.Optional(Type.String({ minLength: 1, description: "Actor to wake as @handle or id; if omitted, the caller" })),
+  observe: Type.Optional(Type.String({ minLength: 1, description: "Named operation without input whose result extends the observed state and is compared by difference" })),
+  instruction: Type.Optional(Type.String({ minLength: 1, maxLength: 2_000, description: "Text appended to every wake, e.g. how the woken actor should react" })),
+  stallAfterSeconds: Type.Optional(Type.Integer({ minimum: 1, description: "Seconds without an event of the observed actor after which the state reports stalledForSeconds" })),
 }, { additionalProperties: false });
 
 export const watchFunctions = (service: WatchServiceApi): ToolContributor => {
   const functions = [
     defineRunFunction({
-      name: "watch_create", label: "Wächter anlegen",
-      description: "Beobachtet einen Actor dieses Runs und weckt einen anderen mit einer Hintergrundnachricht, sobald die als TypeScript-Funktionsrumpf formulierte Bedingung im geänderten Stand einen Grund liefert. Kein Modell: Die Bedingung wird beim Anlegen typgeprüft und danach deterministisch bei jeder Änderung des beobachteten Stands ausgeführt, sobald der beobachtete Actor zur Ruhe gekommen ist; stalledForSeconds erscheint nach stallAfterSeconds ohne Aktivität und danach je weitere Periode erneut. Ein gleicher Wächter wird nicht doppelt angelegt.",
+      name: "watch_create", label: "Create watch",
+      description: "Observes an actor of this run and wakes another with a background message as soon as the condition, written as a TypeScript function body, returns a reason for the changed state. No model: the condition is type-checked on creation and afterwards run deterministically on every change of the observed state, once the observed actor has come to rest; stalledForSeconds appears after stallAfterSeconds without activity and again after each further period. An identical watch is not created twice.",
       schema: createSchema, resultSchema: summarySchema, available,
       run: (scope, _toolCallId, input) => service.create(scope.caller.runId, scope.caller.actorId, input),
     }),
     defineRunFunction({
-      name: "watch_list", label: "Wächter auflisten",
-      description: "Listet die Wächter dieses Runs mit Bedingung, Anzahl der Weckungen und letztem Urteil.",
+      name: "watch_list", label: "List watches",
+      description: "Lists the watches of this run with condition, number of wakes and last verdict.",
       schema: Type.Object({}, { additionalProperties: false }), resultSchema: Type.Array(summarySchema), available,
       run: (scope) => service.list(scope.caller.runId),
     }),
     defineRunFunction({
-      name: "watch_remove", label: "Wächter entfernen",
-      description: "Entfernt einen Wächter dieses Runs; danach weckt er nicht mehr.",
+      name: "watch_remove", label: "Remove watch",
+      description: "Removes a watch of this run; afterwards it no longer wakes.",
       schema: Type.Object({
-        id: Type.String({ minLength: 1, description: "Kennung aus watch_create oder watch_list" }),
-        reason: Type.String({ minLength: 1, description: "Grund der Entfernung" }),
+        id: Type.String({ minLength: 1, description: "Id from watch_create or watch_list" }),
+        reason: Type.String({ minLength: 1, description: "Reason for the removal" }),
       }, { additionalProperties: false }),
       resultSchema: Type.Object({ removed: Type.Literal(true) }, { additionalProperties: false }), available,
       run: (scope, _toolCallId, input) => { service.remove(scope.caller.runId, input.id, input.reason); return { removed: true as const }; },

package/plugins/ragents.watch/server/observation.ts

@@ -61,9 +61,9 @@ export const changesBetween = (before: JsonValue | undefined, after: JsonValue):
   const lines: string[] = [];
   for (const [path, value] of current) {
     const old = previous.get(path);
-    if (old === undefined) lines.push(`${path}: ${value}${before === undefined ? "" : " (neu)"}`);
+    if (old === undefined) lines.push(`${path}: ${value}${before === undefined ? "" : " (new)"}`);
     else if (old !== value) lines.push(`${path}: ${old} -> ${value}`);
   }
-  for (const path of previous.keys()) if (!current.has(path)) lines.push(`${path}: entfernt`);
+  for (const path of previous.keys()) if (!current.has(path)) lines.push(`${path}: removed`);
   return lines;
 };

package/plugins/ragents.watch/server/service.ts

@@ -61,14 +61,14 @@ const invalid = (message: string) => new DomainError("watch-invalid", message, 4
 const cleanText = (value: string | undefined, field: string, limit: number): string | undefined => {
   if (value === undefined) return undefined;
   const text = value.trim();
-  if (!text) throw invalid(`${field} darf nicht leer sein.`);
-  if (text.length > limit) throw invalid(`${field} darf höchstens ${limit} Zeichen enthalten.`);
+  if (!text) throw invalid(`${field} must not be empty.`);
+  if (text.length > limit) throw invalid(`${field} may contain at most ${limit} characters.`);
   return text;
 };
 
 export const wakeMessage = (definition: WatchDefinition, reason: string, changes: readonly string[]): string => [
-  `Der Wächter weckt Dich: ${reason}`,
-  `Änderungen bei @${definition.sourceHandle} seit der letzten Weckung:\n${changes.length ? changes.map((line) => `- ${line}`).join("\n") : "- keine"}`,
+  `The watch wakes you: ${reason}`,
+  `Changes at @${definition.sourceHandle} since the last wake:\n${changes.length ? changes.map((line) => `- ${line}`).join("\n") : "- none"}`,
   ...(definition.instruction ? [definition.instruction] : []),
 ].join("\n");
 
@@ -89,18 +89,18 @@ export class WatchService implements WatchServiceApi {
     const runtime = this.#options.runtime();
     const view = runtime.view(runId);
     const source = watchableActorOf(view, request.source);
-    if (!source) throw invalid(`Der beobachtete Actor ${request.source} existiert in diesem Run nicht.`);
+    if (!source) throw invalid(`The observed actor ${request.source} does not exist in this run.`);
     const target = request.target ? watchableActorOf(view, request.target) : watchableActorOf(view, callerActorId);
-    if (!target) throw invalid(`Der zu weckende Actor ${request.target ?? callerActorId} existiert in diesem Run nicht oder ist kein Agent.`);
+    if (!target) throw invalid(`The actor to wake ${request.target ?? callerActorId} does not exist in this run or is not an agent.`);
     const condition = cleanText(request.condition, "condition", CONDITION_CHARS)!;
     const instruction = cleanText(request.instruction, "instruction", INSTRUCTION_CHARS);
-    if (request.observe !== undefined && !this.#options.operationExists(request.observe)) throw invalid(`Die Operation ${request.observe} ist nicht registriert.`);
-    if (request.stallAfterSeconds !== undefined && (!Number.isInteger(request.stallAfterSeconds) || request.stallAfterSeconds < 1)) throw invalid("stallAfterSeconds muss eine positive ganze Zahl sein.");
+    if (request.observe !== undefined && !this.#options.operationExists(request.observe)) throw invalid(`The operation ${request.observe} is not registered.`);
+    if (request.stallAfterSeconds !== undefined && (!Number.isInteger(request.stallAfterSeconds) || request.stallAfterSeconds < 1)) throw invalid("stallAfterSeconds must be a positive integer.");
     const run = this.#ensure(runId);
     const existing = [...run.watches.values()].find((watch) => watch.definition.sourceActorId === source.id && watch.definition.targetActorId === target.id && watch.definition.condition === condition);
     if (existing) return summaryOf(existing);
     const predicate = await this.#options.compile(condition, run.abort.signal);
-    if (this.#runs.get(runId) !== run) throw invalid("Der Run wurde während des Anlegens beendet.");
+    if (this.#runs.get(runId) !== run) throw invalid("The run ended while the watch was being created.");
     const definition: WatchDefinition = {
       id: `watch_${randomUUID()}`,
       sourceActorId: source.id,
@@ -128,8 +128,8 @@ export class WatchService implements WatchServiceApi {
   remove(runId: string, watchId: string, reason: string): void {
     const run = this.#runs.get(runId);
     const watch = run?.watches.get(watchId);
-    if (!run || !watch) throw new DomainError("watch-unknown", `Der Wächter ${watchId} existiert in diesem Run nicht.`, 404);
-    if (!reason.trim()) throw invalid("reason darf nicht leer sein.");
+    if (!run || !watch) throw new DomainError("watch-unknown", `The watch ${watchId} does not exist in this run.`, 404);
+    if (!reason.trim()) throw invalid("reason must not be empty.");
     run.watches.delete(watchId);
     this.#persist(run);
     this.#updateStallTimer(run);
@@ -173,7 +173,7 @@ export class WatchService implements WatchServiceApi {
   }
 
   #ensure(runId: string): RunWatches {
-    if (this.#closed) throw new Error("Der Wächterdienst ist beendet.");
+    if (this.#closed) throw new Error("The watch service has ended.");
     const existing = this.#runs.get(runId);
     if (existing) return existing;
     const runtime = this.#options.runtime();
@@ -230,7 +230,7 @@ export class WatchService implements WatchServiceApi {
       try { await this.#evaluate(run, watch); }
       catch (error) {
         if (run.abort.signal.aborted) return;
-        (this.#options.log ?? ((message, cause) => console.error(message, cause)))(`Wächter ${watch.definition.id} in Run ${run.runId} konnte nicht bewerten:`, error);
+        (this.#options.log ?? ((message, cause) => console.error(message, cause)))(`Watch ${watch.definition.id} in run ${run.runId} could not evaluate:`, error);
       }
     }
   }
@@ -266,7 +266,7 @@ export class WatchService implements WatchServiceApi {
     watch.lastEvaluated = key;
     watch.lastEvaluatedAt = at;
     watch.lastJudgedChanges = judged;
-    watch.history = [...watch.history, { at, wake: reason !== undefined, reason: reason ?? "Bedingung nicht erfüllt", changes }].slice(-HISTORY_LENGTH);
+    watch.history = [...watch.history, { at, wake: reason !== undefined, reason: reason ?? "Condition not met", changes }].slice(-HISTORY_LENGTH);
     if (reason === undefined) {
       if (changes.some((line) => !line.startsWith("stalledForSeconds:"))) this.#persist(run);
       return;

package/plugins/ragents.workspace/client/transport.ts

@@ -1,7 +1,7 @@
 import { RpcClient } from "../../../apps/web/src/rpc/client";
 import type { WorkspaceClientTransport } from "./workspace-client";
 
-/** Ein Arbeitsplatz-Zugang ohne Oberfläche: die Nachrichtenschicht mit Bearer-Token. */
+/** A workstation access without a user interface: the message layer with a bearer token. */
 export const workspaceClientTransport = (baseUrl: string, token: string | undefined): WorkspaceClientTransport => ({
   rpc: new RpcClient({
     baseUrl: new URL(baseUrl).origin,