@schlenkr/ragents 0.1.4 → 0.1.6

package/bundles/ragents.reference/run-scripts/word-game/src/view.tsx

@@ -0,0 +1,54 @@
+import React from "react";
+import { Button, DocumentViewer } from "@ragents/client/ui";
+import { initialWord, participants, targetCount, type WordGameState } from "./state.js";
+
+export type WordGameViewProps = {
+  state: WordGameState;
+  onStart?: () => void | Promise<void>;
+  busy?: boolean;
+  actionError?: string | undefined;
+  preview?: boolean;
+};
+
+const participantColor: Record<string, string> = {
+  red: "[--word-game-color:#c84f58]",
+  yellow: "[--word-game-color:#b48716]",
+  blue: "[--word-game-color:#487ccc]",
+  green: "[--word-game-color:#408561]",
+};
+const dot = "inline-block size-[9px] shrink-0 rounded-full bg-(--word-game-color)";
+
+export function WordGameView({ state, onStart, busy = false, actionError, preview = false }: WordGameViewProps) {
+  const entries = state.entries ?? [];
+  const active = entries.length % participants.length;
+  const status = state.status ?? "setup";
+  const step = status === "running" ? `${participants[active]!.name} chooses word ${entries.length + 1}.`
+    : status === "completed" ? "Done. All twelve words are in the document."
+      : status === "error" ? "The game was stopped."
+        : status === "ready" ? (preview ? "Ready for the next example step." : "Ready. Start sends the first model task.") : "Setting up participants.";
+
+  return <main className="mx-auto max-w-[760px] text-base">
+    <header className="flex items-center justify-between gap-4">
+      <div><p className="mb-1.5 text-xs text-muted-foreground">TypeScript controls the flow, LLMs choose words</p><h1 className="text-[1.75rem] leading-[1.2] font-semibold">Word game</h1></div>
+      <strong className="text-[1.7rem] tabular-nums" aria-label={`${entries.length} of ${targetCount} entries`}>{entries.length}/{targetCount}</strong>
+    </header>
+    <p className="my-5">Red, Yellow, Blue, and Green take turns. Three rounds, twelve new words. Starting word: <strong>{initialWord}</strong>.</p>
+    <ol className="my-5 grid grid-cols-4 gap-2" aria-label="Participant order">
+      {participants.map((participant, index) => <li key={participant.handle} aria-current={status === "running" && active === index ? "step" : undefined}
+        className={`flex flex-wrap items-center justify-center gap-1.5 rounded-lg border border-border px-1.5 py-3 max-[420px]:text-[0.75rem] aria-[current=step]:border-(--word-game-color) aria-[current=step]:bg-muted aria-[current=step]:ring-1 aria-[current=step]:ring-(--word-game-color) ${participantColor[participant.handle]}`}>
+        <span className={dot} aria-hidden="true" /><strong>{participant.name}</strong><small className="w-full text-center text-muted-foreground">LLM</small>
+      </li>)}
+    </ol>
+    <progress className="block h-1.5 w-full [accent-color:#408561]" value={entries.length} max={targetCount} aria-label="Completed entries" />
+    <p className="my-3" role="status">{step}</p>
+    {status === "ready" && <Button disabled={busy || !onStart} onClick={() => void onStart?.()}>{busy ? "Sending start..." : preview ? "Show example" : "Start word game"}</Button>}
+    {(state.error || actionError) && <p className="border-l-[3px] border-destructive bg-destructive-soft p-3" role="alert">{state.error || actionError}{status === "error" ? " Start a new word-game run. The current state remains available." : ""}</p>}
+    <section className="mt-6 border-t border-border pt-4" aria-label="Collected words">
+      <h2 className="mb-3 text-lg font-semibold">{status === "completed" ? "Completed document" : "Word sequence"}</h2>
+      {state.document && status === "completed" ? <DocumentViewer content={state.document} format="markdown" filename="word-game.md" /> : entries.length === 0 ? <p className="text-muted-foreground">{preview ? "The word sequence grows here from labeled example data." : "No model response yet. The shared word sequence grows here."}</p> : <ol className="mb-5 grid grid-cols-2 gap-x-5 max-[420px]:grid-cols-1">
+        {entries.map((entry, index) => <li key={index} className={`flex min-h-9 items-center gap-2 border-b border-border ${participantColor[participants[entry.participant]!.handle]}`}>
+          <span className="w-[22px] text-muted-foreground tabular-nums">{index + 1}.</span><span className={dot} aria-hidden="true" /><strong className="[overflow-wrap:anywhere]">{entry.word}</strong><small className="ml-auto text-muted-foreground">{participants[entry.participant]!.name}</small></li>)}
+      </ol>}
+    </section>
+  </main>;
+}

package/bundles/ragents.reference/run-scripts/word-game/tests/program.test.ts

@@ -0,0 +1,252 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createTestContext } from "@ragents/server/testing";
+import type { ActorInput, CapabilityContracts } from "@ragents/server";
+import program from "../src/server.ts";
+import { participants, type WordGameState } from "../src/state.ts";
+
+const message = (content: string): ActorInput => ({ id: "input", content, artifactIds: [], sourceEventIds: [], subscriptionId: null, event: null });
+const firstInput = message(JSON.stringify({ input: null, options: {} }));
+const words = ["Strand", "Sand", "Wüste", "Kamel", "Oase", "Wasser", "Fluss", "Brücke", "Stadt", "Haus", "Garten", "Blume"];
+type History = CapabilityContracts["event_query"]["output"];
+
+function fixture(initialState: WordGameState = {}) {
+  const calls: { name: string; input: unknown }[] = [];
+  const history: History = [];
+  const settings = { missingProfile: false, failDispatch: false };
+  const context = createTestContext<WordGameState>({
+    state: initialState,
+    functions: {
+      model_list: async (input) => {
+        calls.push({ name: "model_list", input });
+        return { profiles: settings.missingProfile ? [] : [{ name: "standard", driver: "agent", description: "Test", turnTimeoutMs: null, isolateWorkspace: false, provider: "test", model: "test" }], models: [] };
+      },
+      agent_spawn: async (input) => {
+        calls.push({ name: "agent_spawn", input });
+        return { id: `actor-${input.handle}`, handle: input.handle };
+      },
+      run_configure: async (input) => { calls.push({ name: "run_configure", input }); return null; },
+      canvas_layout_replace: async (input) => { calls.push({ name: "canvas_layout_replace", input }); return null; },
+      event_subscribe: async (input) => {
+        calls.push({ name: "event_subscribe", input });
+        return { subscriptionId: "subscription", sources: input.sourceActorIds ?? null };
+      },
+      actor_input: async (input) => {
+        calls.push({ name: "actor_input", input });
+        if (settings.failDispatch) throw new Error("Übergabe fehlgeschlagen");
+        return [{ type: "actor.input.enqueued", payload: { actorId: input.actor, inputId: `request-${calls.length}` } }];
+      },
+      event_query: async (input) => { calls.push({ name: "event_query", input }); return history.filter((event) => input.actorIds?.includes(event.actorId)); },
+    },
+  });
+
+  const response = (word: string, options: { actorId?: string; inputId?: string; outcome?: string; type?: string; subscriptionId?: string } = {}): ActorInput => {
+    const state = context.state.read();
+    const index = state.entries?.length ?? 0;
+    const actorId = options.actorId ?? state.participants![index % 4]!.id;
+    const turnId = `turn-${history.length}`;
+    const envelope = { actorId, causationId: null, commandId: "test", correlationId: null, occurredAt: "2026-09-13T12:00:00Z", runId: "test", schemaVersion: 3 as const };
+    history.push({ ...envelope, eventId: `${turnId}-start`, sequence: history.length + 1, type: "turn.started", payload: { turnId, inputId: options.inputId ?? state.pendingInputId } });
+    history.push({ ...envelope, eventId: `${turnId}-output`, sequence: history.length + 1, type: "model.output.completed", payload: { turnId, text: word } });
+    return { ...message("Ereignis"), subscriptionId: options.subscriptionId ?? "subscription", sourceEventIds: [`${turnId}-finished`],
+      event: { type: options.type ?? "turn.finished", eventId: `${turnId}-finished`, sequence: history.length + 1, occurredAt: envelope.occurredAt,
+        sourceActorId: actorId, sourceActorHandle: null, payload: { turnId, outcome: options.outcome ?? "completed", reason: "Testunterbrechung" } } };
+  };
+  const start = async () => {
+    await program.onInput(firstInput, context);
+    await program.functions.start({}, context);
+    await program.onInput(message("START_WORD_GAME"), context);
+  };
+  return { context, calls, history, settings, response, start };
+}
+
+test("richtet vier reine LLMs und die eigene View ohne Modellauftrag ein", async () => {
+  const { context, calls } = fixture();
+  await program.onInput(firstInput, context);
+  assert.equal(context.state.read().status, "ready");
+  assert.deepEqual(calls.filter((call) => call.name === "agent_spawn").map((call) => {
+    const input = call.input as { handle: string; displayName: string; tools: unknown; profile: string };
+    return { handle: input.handle, name: input.displayName, tools: input.tools, profile: input.profile };
+  }), participants.map((participant) => ({ ...participant, tools: [], profile: "standard" })));
+  assert.equal(calls.some((call) => call.name === "actor_input"), false);
+  assert.deepEqual(calls.find((call) => call.name === "run_configure")!.input, { title: "Wortspiel", primaryActor: "test-actor" });
+  const before = structuredClone(context.state.read());
+  const callCount = calls.length;
+  await assert.rejects(async () => program.onInput(firstInput, context), /keine freien Chatnachrichten/);
+  assert.deepEqual(context.state.read(), before);
+  assert.equal(calls.length, callCount);
+});
+
+test("der App-Aufruf schickt nur einen Auftrag an den eigenen Steueractor", async () => {
+  const { context, calls } = fixture();
+  await program.onInput(firstInput, context);
+  assert.deepEqual(await program.functions.start({}, context), { accepted: true });
+  assert.deepEqual(calls.at(-1), { name: "actor_input", input: { actor: "test-actor", content: "START_WORD_GAME" } });
+  assert.equal(calls.some((call) => call.name === "event_subscribe"), false);
+  assert.equal(context.state.read().status, "ready");
+});
+
+test("wartet auf spätere Ereignisse, zählt zwölf Beiträge und beendet die Weitergabe", async () => {
+  const { context, calls, response, start } = fixture();
+  await start();
+  assert.deepEqual(calls.slice(-2).map((call) => call.name), ["event_subscribe", "actor_input"]);
+  for (const word of words) await program.onInput(response(word), context);
+  const inputs = calls.filter((call) => call.name === "actor_input" && (call.input as { actor: string }).actor !== "test-actor");
+  assert.equal(inputs.length, 12);
+  assert.deepEqual(inputs.map((call) => (call.input as { actor: string }).actor), words.map((_word, index) => `actor-${participants[index % 4]!.handle}`));
+  assert.equal(context.state.read().status, "completed");
+  assert.equal(context.state.read().entries?.length, 12);
+  assert.match(context.state.read().document!, /12\. Grün: Blume/);
+  assert.equal(context.state.read().pendingInputId, undefined);
+  assert.deepEqual(await program.functions.start({}, context), { accepted: false });
+});
+
+test("ignoriert falsche Quellen, fremde Aufträge, falsche Abos und doppelte Ereignisse", async () => {
+  const { context, calls, response, start } = fixture();
+  await start();
+  await program.onInput(response("Fremd", { actorId: "actor-blue" }), context);
+  await program.onInput(response("Fremd", { inputId: "foreign-input" }), context);
+  await program.onInput(response("Fremd", { subscriptionId: "foreign-subscription" }), context);
+  assert.equal(context.state.read().entries?.length, 0);
+  const first = response(words[0]!);
+  await program.onInput(first, context);
+  await program.onInput(first, context);
+  for (const word of words.slice(1, 4)) await program.onInput(response(word), context);
+  const before = calls.filter((call) => call.name === "actor_input").length;
+  await program.onInput(first, context);
+  assert.equal(context.state.read().entries?.length, 4);
+  assert.equal(calls.filter((call) => call.name === "actor_input").length, before);
+});
+
+for (const scenario of [
+  { name: "Modellfehler", word: "Strand", options: { outcome: "failed" } },
+  { name: "Unterbrechung", word: "Strand", options: { type: "turn.interrupted" } },
+  { name: "Mehrwortantwort", word: "Schöner Strand", options: {} },
+  { name: "wiederholtes Ausgangswort", word: "sonne", options: {} },
+]) {
+  test(`${scenario.name} bleibt als Fehler sichtbar und startet nicht erneut`, async () => {
+    const { context, calls, response, start } = fixture();
+    await start();
+    await program.onInput(response(scenario.word, scenario.options), context);
+    assert.equal(context.state.read().status, "error");
+    assert.ok(context.state.read().error);
+    const before = calls.length;
+    await program.onInput(message("START_WORD_GAME"), context);
+    assert.deepEqual(await program.functions.start({}, context), { accepted: false });
+    assert.equal(calls.length, before);
+    assert.equal(context.state.read().entries?.length, 0);
+  });
+}
+
+test("ein weiterer Start während des Spiels verändert keinen Auftrag oder Fortschritt", async () => {
+  const { context, calls, start } = fixture();
+  await start();
+  const before = calls.length;
+  await program.onInput(message("START_WORD_GAME"), context);
+  assert.deepEqual(await program.functions.start({}, context), { accepted: false });
+  assert.equal(calls.length, before);
+});
+
+for (const status of ["ready", "running", "completed"]) {
+  test(`freie Chatnachrichten werden bei ${status} abgelehnt und erhalten den Spielstand`, async () => {
+    const { context, calls, response } = fixture();
+    await program.onInput(firstInput, context);
+    if (status !== "ready") {
+      await program.onInput(message("START_WORD_GAME"), context);
+      const contributions = status === "completed" ? words : words.slice(0, 1);
+      for (const word of contributions) await program.onInput(response(word), context);
+    }
+    assert.equal(context.state.read().status, status);
+    const before = structuredClone(context.state.read());
+    const callCount = calls.length;
+    const content = "Starte das Wortspiel bitte noch einmal von vorn.";
+    await assert.rejects(async () => program.onInput(message(content), context), /keine freien Chatnachrichten.*Startknopf.*neuer Run/);
+    assert.deepEqual(context.state.read(), before);
+    assert.equal(calls.length, callCount);
+    if (status === "ready") {
+      await program.onInput(message("START_WORD_GAME"), context);
+      assert.equal(context.state.read().status, "running");
+    } else if (status === "running") {
+      for (const word of words.slice(1)) await program.onInput(response(word), context);
+      assert.equal(context.state.read().status, "completed");
+      assert.equal(context.state.read().entries?.length, 12);
+    }
+  });
+}
+
+test("eine fehlgeschlagene Übergabe erhält das bereits angenommene Wort", async () => {
+  const { context, settings, response, start } = fixture();
+  await start();
+  settings.failDispatch = true;
+  await program.onInput(response("Strand"), context);
+  assert.equal(context.state.read().status, "error");
+  assert.deepEqual(context.state.read().entries, [{ participant: 0, word: "Strand" }]);
+  assert.match(context.state.read().error!, /Übergabe/);
+});
+
+test("fehlendes Standardprofil zeigt einen Fehler ohne Teilnehmer anzulegen", async () => {
+  const { context, settings, calls } = fixture();
+  settings.missingProfile = true;
+  await program.onInput(firstInput, context);
+  assert.equal(context.state.read().status, "error");
+  assert.match(context.state.read().error!, /Rolle standard fehlt/);
+  assert.deepEqual(calls.map((call) => call.name), ["run_configure", "canvas_layout_replace", "model_list"]);
+});
+
+test("ein wiederhergestellter Zustand zählt den wartenden Auftrag weiter und baut nichts neu", async () => {
+  const previous = fixture();
+  await previous.start();
+  await program.onInput(previous.response(words[0]!), previous.context);
+  const restored = fixture(previous.context.state.read());
+  const before = structuredClone(restored.context.state.read());
+  await assert.rejects(async () => program.onInput(firstInput, restored.context), /keine freien Chatnachrichten/);
+  assert.deepEqual(restored.context.state.read(), before);
+  assert.equal(restored.calls.length, 0);
+  await program.onInput(restored.response(words[1]!), restored.context);
+  assert.equal(restored.context.state.read().entries?.length, 2);
+  assert.equal(restored.context.state.read().status, "running");
+  assert.equal(restored.calls.some((call) => call.name === "agent_spawn"), false);
+});
+
+test("fehlende oder mehrfache Modellausgaben werden nicht als Wort übernommen", async () => {
+  for (const count of [0, 2]) {
+    const { context, history, response, start } = fixture();
+    await start();
+    const input = response("Strand");
+    const output = history.pop()!;
+    for (let index = 0; index < count; index++) history.push({ ...output, eventId: `output-${index}` });
+    await program.onInput(input, context);
+    assert.equal(context.state.read().status, "error");
+    assert.equal(context.state.read().entries?.length, 0);
+  }
+});
+
+test("ungültige Startdaten bleiben als Fehler sichtbar und starten kein Modell", async () => {
+  for (const content of ["kein JSON", JSON.stringify({ input: "Strand", options: {} }), JSON.stringify({ input: null, options: [] })]) {
+    const { context, calls } = fixture();
+    await program.onInput(message(content), context);
+    assert.equal(context.state.read().status, "error");
+    assert.equal(calls.some((call) => call.name === "agent_spawn"), false);
+  }
+});
+
+test("akzeptiert die Startoptionen des Profils ohne eigene Modellvorgaben daraus abzuleiten", async () => {
+  const { context, calls } = fixture();
+  await program.onInput(message(JSON.stringify({ input: null, options: {
+    "ragents.model": { model: "test-model", thinking: "off" },
+    "ragents.system-prompt": { promptIds: [], shareWithAgents: false },
+  } })), context);
+  assert.equal(context.state.read().status, "ready");
+  assert.equal(calls.filter((call) => call.name === "agent_spawn").length, 4);
+  assert.ok(calls.filter((call) => call.name === "agent_spawn").every((call) => (call.input as { profile: string }).profile === "standard"));
+  assert.equal(calls.some((call) => call.name === "actor_input"), false);
+});
+
+test("ein gestoppter aktueller Teilnehmer hält das Spiel an", async () => {
+  const { context, response, start } = fixture();
+  await start();
+  await program.onInput(response("Strand", { type: "actor.stopped" }), context);
+  assert.equal(context.state.read().status, "error");
+  assert.match(context.state.read().error!, /Rot wurde gestoppt/);
+  assert.equal(context.state.read().entries?.length, 0);
+});

package/bundles/ragents.reference/server/index.js

@@ -0,0 +1,16 @@
+import { createRequire as __ragentsCreateRequire } from "node:module";
+const require = __ragentsCreateRequire(import.meta.url);
+
+// server/index.ts
+var referencePlugin = {
+  manifest: { id: "ragents.reference" },
+  register: () => void 0
+};
+var plugin = {
+  requires: ["ragents.orchestration", "ragents.actor-programs"],
+  create: () => referencePlugin
+};
+export {
+  plugin
+};
+//# sourceMappingURL=index.js.map

package/bundles/ragents.reference/server/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../plugins/ragents.reference/server/index.ts"],
+  "sourcesContent": ["import type { RAgentsPlugin } from \"@ragents/engine\";\nimport type { PluginModule } from \"@ragents/host/plugin-support/plugin-module.js\";\n\nconst referencePlugin: RAgentsPlugin = {\n  manifest: { id: \"ragents.reference\" },\n  register: () => undefined,\n};\n\nexport const plugin: PluginModule = {\n  requires: [\"ragents.orchestration\", \"ragents.actor-programs\"],\n  create: () => referencePlugin,\n};\n"],
+  "mappings": ";;;;AAGA,IAAM,kBAAiC;AAAA,EACrC,UAAU,EAAE,IAAI,oBAAoB;AAAA,EACpC,UAAU,MAAM;AAClB;AAEO,IAAM,SAAuB;AAAA,EAClC,UAAU,CAAC,yBAAyB,wBAAwB;AAAA,EAC5D,QAAQ,MAAM;AAChB;",
+  "names": []
+}

package/bundles/ragents.reference/skills/100-shared-actor-list/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 100-shared-actor-list
+start: true
+disable-model-invocation: true
+title: "Eine Liste im Chat und im Fenster pflegen"
+description: "Zeigt beim Aufbau einer Mini-App, wie Oberfläche und Koordinator dieselbe Funktion eines TypeScript-Actors benutzen und dieselbe Liste ändern."
+category: "Mini-Apps"
+order: 100
+tags: "Anwendungsfall, Konzeptdemo, TypeScript-Actors, Actor-Funktionen, Actor-Zustand, Mini-Apps"
+---
+
+Ich hätte gern eine gemeinsame Liste an einem TypeScript-Actor ohne KI-Listenhelfer. Ich ergänze Einträge über seine Oberfläche, Du über dieselbe Funktion als Werkzeug. Beide Wege zeigen sofort denselben Stand, auch bei ruhendem Chat. Füge wirklich einen Eintrag hinzu und lass die Oberfläche stehen. Nutze gemeinsame Layout- und Formularbausteine: mehrzeilige Eingabe und Liste nebeneinander, bei wenig Platz untereinander.

package/bundles/ragents.reference/skills/110-all-card-slots/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 110-all-card-slots
+start: true
+disable-model-invocation: true
+title: "Rückfrage, Aufgaben und Dokument zusammen sehen"
+description: "Zeigt, wie Aufgabenstand, Dokument und eine offene Rückfrage gleichzeitig an einer Agentenkarte sichtbar bleiben."
+category: "Zusammenarbeit"
+order: 110
+tags: "Rückfragen, To-dos, Konzeptdemo"
+---
+
+Ich hätte gern eine KI, die mir drei Aufgaben notiert - eine erledigte, eine in Arbeit und eine offene -, dazu ein kurzes Dokument schreibt und mich zum Schluss fragt, ob sie den offenen Punkt als Nächstes angehen soll. Antworte diese Frage nicht für mich, sondern halt dort an, damit ich Aufgabenliste, Dokument und Frage zusammen sehe und selbst antworten kann.

package/bundles/ragents.reference/skills/150-editorial-workbench/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 150-editorial-workbench
+start: true
+disable-model-invocation: true
+title: "Redaktionswerkstatt"
+description: "Zeigt, wie eine Mini-App Textbearbeitung, einzeln übernehmbare Änderungen und ein Bearbeitungsprotokoll zu einer Redaktionswerkstatt verbindet."
+category: "Mini-Apps"
+order: 150
+tags: "Actor-Funktionen, Anwendungsfall, Konzeptdemo, Mini-Apps"
+---
+
+Ich hätte gern eine Redaktionswerkstatt: Reparaturtreff, Samstag 10 bis 14 Uhr, Nachbarschaftshaus, ehrenamtliche Hilfe, keine Garantie. Links wähle ich Original oder Kurzfassung, rechts ändere ich Text und Zielgruppe und übernehme Kürzungen einzeln. Zeige Änderungen und Aufgabenstand, vergleiche Wortzahl und Freigabe tabellarisch. Ein Helfer zählt die Wörter; ein Protokoll zeigt Absender, Übernahmen und Rücknahmen. Veröffentliche nichts.

package/bundles/ragents.reference/skills/160-learning-companion/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 160-learning-companion
+start: true
+disable-model-invocation: true
+title: "Lernbegleitung mit Unterlagen"
+description: "Zeigt eine eigene Mini-App eines KI-Tutors mit eingebettetem Actor-Chat. Lokal gewählte Unterlagen gelangen erst nach einer ausdrücklichen Aktion ins Gespräch."
+category: "Mini-Apps"
+order: 160
+tags: "Anwendungsfall, Konzeptdemo, Agententeams, Mini-Apps, LLM-Actor mit View, Actor-Chat"
+---
+
+Ich hätte gern einen KI-Tutor mit eigener Oberfläche auf der Fläche: Textunterlagen öffnen und lesen, daneben mit genau diesem Tutor sprechen. Ich möchte zwischen Erklären, Beispiel und Verständnisprüfung wählen. Die ausgewählte Datei soll erst nach meinem Klick im Gespräch verwendet werden. Fragen ohne Datei sollen auch gehen. Nutze die vorhandenen Chat-, Datei- und Auswahlbausteine.

package/bundles/ragents.reference/skills/170-photo-collection/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 170-photo-collection
+start: true
+disable-model-invocation: true
+title: "Bildsammlung mit Beschriftungen"
+description: "Zeigt eine eigene Mini-App eines KI-Schreibhelfers mit Bildvorschauen, bearbeitbaren Beschriftungen und direktem Chat. Die Auswahl lokaler Bilder sendet sie noch nicht an die KI."
+category: "Mini-Apps"
+order: 170
+tags: "Anwendungsfall, Konzeptdemo, Agententeams, Mini-Apps, LLM-Actor mit View, Actor-Chat"
+---
+
+Ich hätte gern einen KI-Schreibhelfer mit eigener Oberfläche für eine kleine Bildsammlung: Bilder hineinziehen, Vorschauen sehen, die Liste durchsuchen und pro Bild Titel, Bildunterschrift und Alternativtext bearbeiten. Daneben möchte ich einen Chat mit genau diesem Schreibhelfer und eine lesbare Übersicht aller Beschriftungen. Meine Bilder bleiben lokal, bis ich selbst etwas im Chat sende. Nutze die vorhandenen Bausteine.

package/bundles/ragents.reference/skills/180-decision-workbench/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 180-decision-workbench
+start: true
+disable-model-invocation: true
+title: "Entscheidungswerkstatt"
+description: "Zeigt ein fest geführtes Gespräch ohne KI-Aufrufe. Ein TypeScript-Actor hält Antworten und Fortschritt; Änderungen am Entscheidungsentwurf werden sichtbar."
+category: "Mini-Apps"
+order: 180
+tags: "Anwendungsfall, Konzeptdemo, TypeScript-Actors, Actor-Zustand, Mini-Apps, Frei gesteuerter Chat"
+---
+
+Ich hätte gern eine lokale Entscheidungshilfe: Bibliothek oder Café als Lernort? Feste Fragen führen durch Ziel, Optionen und Kriterien, protokollieren meine Entscheidung und zeigen den Fortschritt. Bei einer Meinungsänderung will ich den Unterschied zum vorherigen Entwurf sehen. Ein TypeScript-Actor führt den gemeinsamen Fortschritt und die Antworten. Das soll eine klar erkennbare Anleitung ohne KI-Aufrufe sein, mit den vorhandenen Chatbausteinen.

package/bundles/ragents.reference/skills/190-review-queue/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 190-review-queue
+start: true
+disable-model-invocation: true
+title: "Texte prüfen und Ergebnisse gezielt teilen"
+description: "Zeigt an drei Textprüfungen die Input-Warteschlange, gezielte Ergebnisfreigaben und den Actor-Stopp. Die Mini-App sammelt ungeschützte Statusmeldungen."
+category: "Mini-Apps"
+order: 190
+tags: "Journalprüfung, Anwendungsfall, Konzeptdemo, Agententeams, Input-Warteschlange, Actor-Stopp, Artefakte und Zugriff, Mini-Apps"
+---
+
+Ich hätte gern drei getrennte Textprüfungen zum Nachbarschaftsfest, die ich während der ersten Prüfung einreihe. Nur der bestimmte Empfänger darf das erste Ergebnis lesen; prüfe auch einen Zugriff ohne Freigabe. Danach meldest du den Prüfer ab. Belege Reihenfolge, Zugriff und Stopp. Eine Oberfläche des vorhandenen Koordinators zeigt auf der Fläche nur ungeschützte Statusmeldungen verschiedener Absender. Eine eigene Notiz möchte ich ergänzen können.

package/bundles/ragents.reference/skills/20-circle-of-four/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 20-circle-of-four
+start: true
+disable-model-invocation: true
+title: "Eine Liste durch vier KI-Helfer reichen"
+description: "Zeigt beim Aufbau eines Wortspiels, wie vier KI-Helfer nacheinander beitragen und ein TypeScript-Actor die Weitergabe nach zwölf Wörtern beendet."
+category: "Zusammenarbeit"
+order: 20
+tags: "Anwendungsfall, Konzeptdemo, Agententeams, TypeScript-Actors, Subscriptions"
+---
+
+Ich hätte gern vier KIs mit den Namen rot, gelb, blau und grün, die reihum ein Wortspiel spielen: jede hängt ein Wort an, das ihr zum zuletzt genannten einfällt. Nach zwölf Beiträgen ist Schluss, und ich will die fertige Liste als Dokument sehen.

package/bundles/ragents.reference/skills/200-typescript-diagnostics/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 200-typescript-diagnostics
+start: true
+disable-model-invocation: true
+title: "Fehler in einer Terminliste finden"
+description: "Zeigt an einer TypeScript-Terminliste, wie sich echte Sprachdiagnosen nach jeder einzelnen Korrektur ändern. Das korrigierte Beispiel bleibt zum Nachlesen erhalten."
+category: "Code und Diagnose"
+order: 200
+tags: "Anwendungsfall, Konzeptdemo, Sprachprüfung"
+---
+
+Ich hätte gern eine kleine TypeScript-Terminliste mit zwei absichtlichen Typfehlern. Lass die Sprachprüfung beide finden und korrigiere sie einzeln. Nach jeder Korrektur möchte ich den echten Befund sehen. Am Ende bleiben das korrigierte Beispiel und ein kurzer Vergleich zum Nachlesen. Falls die Sprachprüfung fehlt, sag das klar.

package/bundles/ragents.reference/skills/210-moderator-handover/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 210-moderator-handover
+start: true
+disable-model-invocation: true
+title: "Gespräch an einen Moderator übergeben"
+description: "Zeigt die Übergabe eines laufenden Chats an einen anderen Primary-Actor. Der Moderator übernimmt als direkter Ansprechpartner und hält den Aufgabenfortschritt fest."
+category: "Zusammenarbeit"
+order: 210
+tags: "Rückfragen, To-dos, Anwendungsfall, Konzeptdemo, Agententeams, Primary-Actor"
+---
+
+Ich hätte gern einen Workshop für einen ruhigeren Arbeitstag: Ein Planer bringt zwei Ideen mit, ein skeptischer Gast prüft die Nachteile. Ein Moderator übernimmt die Runde und spricht danach direkt mit mir im Chat, damit ich einen Vorschlag auswählen kann. Zeig die drei auf der Fläche und übergib das Gespräch wirklich an den Moderator. Seine Aufgabenliste zeigt den Fortschritt.

package/bundles/ragents.reference/skills/220-actor-approval-list/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 220-actor-approval-list
+start: true
+disable-model-invocation: true
+title: "Vorschläge gemeinsam freigeben"
+description: "Zeigt einen KI-Listenhelfer mit eigener Mini-App und gemeinsamem Zustand. Seine Vorschläge lassen sich per Funktion bestätigen, ohne eine weitere KI-Antwort abzuwarten."
+category: "Mini-Apps"
+order: 220
+tags: "Anwendungsfall, Konzeptdemo, Agententeams, Actor-Funktionen, Actor-Zustand, Mini-Apps, LLM-Actor mit View, Frei gesteuerter Chat"
+---
+
+Ich hätte gern einen KI-Listenhelfer mit eigener Oberfläche. Dort prüfe und bestätige ich seine Vorschläge; bestätigte Einträge stehen daneben. Der Helfer benutzt dieselben Funktionen und dieselbe Liste, wenn ich ihn im Chat um einen Eintrag bitte. Lass ihn einen echten Vorschlag machen. Die Freigabe per Knopf soll ohne weitere KI-Antwort seinen gespeicherten Vorschlag bestätigen. Danach möchte ich selbst einen eingeben.

package/bundles/ragents.reference/skills/230-shared-state-views/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 230-shared-state-views
+start: true
+disable-model-invocation: true
+title: "Eine Liste in zwei Ansichten"
+description: "Zeigt zwei Mini-App-Ansichten desselben Actor-Zustands. Änderungen erscheinen in beiden; eine Ansicht lässt sich unabhängig ausblenden."
+category: "Mini-Apps"
+order: 230
+tags: "Anwendungsfall, Konzeptdemo, Actor-Funktionen, Actor-Zustand, Mini-Apps"
+---
+
+Ich hätte gern eine Aufgabenliste mit zwei kleinen Fenstern: In einem ergänze und erledige ich Aufgaben, im anderen sehe ich nur offene und erledigte Anzahlen. Beide gehören zum selben Helfer und benutzen dieselben Daten. Ergänze wirklich eine Aufgabe und erledige sie. Beide Fenster sollen sofort mitziehen. Danach blende nur die Zusammenfassung aus und wieder ein; meine Liste bleibt erhalten.

package/bundles/ragents.reference/skills/240-live-result-list/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 240-live-result-list
+start: true
+disable-model-invocation: true
+title: "Antworten automatisch sammeln"
+description: "Zeigt, wie ein TypeScript-Actor fertige Agentenantworten per Abonnement automatisch sammelt. Auch weitere Beiträge desselben Helfers lassen die Liste wachsen."
+category: "Mini-Apps"
+order: 240
+tags: "Anwendungsfall, Konzeptdemo, TypeScript-Actors, Subscriptions, Actor-Zustand, Mini-Apps"
+---
+
+Ich hätte gern zwei KI-Helfer, die je eine kurze Idee für einen gemeinsamen Lernnachmittag vorschlagen. Ihre fertigen Antworten sollen automatisch in einer kleinen Ergebnisliste auf der Fläche erscheinen. Ein programmierter Sammler merkt sich die Beiträge; dafür soll keine weitere KI die Texte kopieren. Lass danach einen Helfer eine zweite Idee ergänzen. Die Liste soll von selbst wachsen, auch wenn Du im Chat gerade nichts schreibst.

package/bundles/ragents.reference/skills/250-balcony-wizard/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 250-balcony-wizard
+start: true
+disable-model-invocation: true
+title: "Balkon-Wizard"
+description: "Zeigt den Aufbau einer eigenständigen Mini-App für ein adaptives KI-Interview. Das LLM wählt die Fragen, das Formular begrenzt das Gespräch auf fünf Antworten."
+category: "Mini-Apps"
+order: 250
+tags: "Anwendungsfall, Konzeptdemo, Mini-Apps, Actor-Funktionen, Actor-Zustand"
+---
+
+Ich hätte gern einen Balkon-Wizard als eigenständige App auf der Fläche. Sie vermittelt ein begrenztes Gespräch mit einem KI-Berater im Hintergrund. Nach jeder Antwort wählt das LLM die nächste passende Frage, keine feste Fragenliste. Nach fünf Antworten gibt es Gestaltungstipps. Ich antworte nur in der App; sie zeigt Frage, Fortschritt, Lade- und Fehlerzustände. Nutze gemeinsame Layouts und Formulare. Keine App in einer LLM-Chatkarte.

package/bundles/ragents.reference/skills/30-llm-without-runtime-knowledge/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 30-llm-without-runtime-knowledge
+start: true
+disable-model-invocation: true
+title: "Eine Nachricht überbringen lassen"
+description: "Zeigt eine einseitige Weiterleitung zwischen zwei KI-Helfern, die den Ablauf und den anderen Teilnehmer nicht kennen."
+category: "Zusammenarbeit"
+order: 30
+tags: "Konzeptdemo, Agententeams, Subscriptions, Actor-Stopp"
+---
+
+Ich hätte gern zwei KIs, anna und ben, die sich genau einmal freundlich begrüßen, ohne voneinander oder von der Technik dahinter zu wissen: anna sagt einen herzlichen Satz, ben antwortet einmal darauf, danach ist Schluss. Sag mir hinterher kurz, dass wirklich nur in diese eine Richtung weitergereicht wurde und danach alles wieder aufgeräumt ist.

package/bundles/ragents.reference/skills/35-actor-input-fifo/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 35-actor-input-fifo
+start: true
+disable-model-invocation: true
+title: "Drei Aufträge der Reihe nach erledigen"
+description: "Zeigt, ob während eines laufenden Turns eingereihte Aufträge getrennt und in Eingangsreihenfolge verarbeitet werden. Das Journal liefert die Belege."
+category: "Ereignisse und Abläufe"
+order: 35
+tags: "Journalprüfung, Konzeptdemo, Input-Warteschlange"
+---
+
+Ich hätte gern einen Helfer, der jeden Text, den ich ihm gebe, mit "ERLEDIGT: " und dem unveränderten Text beantwortet und beim Wort "eins" vorher ausgiebig nachdenkt. Während er noch an "eins" sitzt, schiebe ich ihm "zwei" und "drei" hinterher. Zeig mir danach mit Belegen, dass er alle drei sauber getrennt und genau in dieser Reihenfolge abgearbeitet hat und nichts vermischt wurde.

package/bundles/ragents.reference/skills/40-subscription-matrix/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 40-subscription-matrix
+start: true
+disable-model-invocation: true
+title: "Gezielt bei anderen Helfern mithören"
+description: "Zeigt, wie Abonnements nach Absender und Ereignisart filtern. Eine belegte Empfangstabelle macht passende und ausgeschlossene Ereignisse sichtbar."
+category: "Ereignisse und Abläufe"
+order: 40
+tags: "Journalprüfung, Konzeptdemo, Subscriptions"
+---
+
+Ich hätte gern drei KIs a, b und c und dazu zwei Zuhörer: der eine soll nur mitbekommen, was a und b sagen, der andere nur, wenn eine der drei tatsächlich etwas ausgeführt hat. Lass danach alle drei etwas sagen und mindestens eine wirklich etwas tun. Gib mir am Ende eine Tabelle, bei welchem Zuhörer was angekommen ist und was nicht, und belege sie.

package/bundles/ragents.reference/skills/50-subscription-removal/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 50-subscription-removal
+start: true
+disable-model-invocation: true
+title: "Eine Weiterleitung wieder abschalten"
+description: "Zeigt die Wirkung eines entfernten Abonnements: Die erste Nachricht kommt an, nach dem Abschalten endet die Weiterleitung."
+category: "Ereignisse und Abläufe"
+order: 50
+tags: "Konzeptdemo, Subscriptions"
+---
+
+Ich hätte gern drei KIs: eine Quelle, eine Senke und eine dazwischen, die jedes Wort der Quelle wortgleich an die Senke durchreicht. Lass die Quelle zuerst "eins" sagen, nimm der mittleren danach das Mithören wieder weg und lass die Quelle "zwei" sagen. Erklär mir mit Belegen, was beim zweiten Mal passiert und ob bei der Senke noch etwas ankommt.

package/bundles/ragents.reference/skills/60-stop-in-the-circle/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 60-stop-in-the-circle
+start: true
+disable-model-invocation: true
+title: "Einen Helfer in der Gesprächsrunde stoppen"
+description: "Zeigt, wie der Stopp eines Actors eine Übergabekette unterbricht und was nachfolgende Actors noch erhalten."
+category: "Ereignisse und Abläufe"
+order: 60
+tags: "Journalprüfung, Konzeptdemo, Actor-Stopp"
+---
+
+Ich hätte gern vier KIs rot, gelb, blau und grün, die im Kreis eine Liste weiterreichen und jede eine eigene Zeile anhängt. Sobald die Liste einmal ganz herum war, schalte blau ab. Erzähl mir mit Belegen, woran die nächste Runde scheitert und ob grün danach überhaupt noch etwas bekommt.

package/bundles/ragents.reference/skills/65-artifact-least-privilege/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 65-artifact-least-privilege
+start: true
+disable-model-invocation: true
+title: "Eine Notiz gezielt weitergeben"
+description: "Zeigt, wie die ausdrückliche Weitergabe einer Notiz den Lesezugriff steuert und ein abgelehnter Zugriff die Freigabe unverändert lässt."
+category: "Dateien und Ergebnisse"
+order: 65
+tags: "Konzeptdemo, Artefakte und Zugriff"
+---
+
+Ich hätte gern drei KIs: die erste schreibt eine kurze geheime Notiz und gibt sie ausdrücklich an die zweite weiter, die dritte erfährt nur, dass es die Notiz gibt. Prüf für mich, wer sie wirklich lesen kann und wer nicht, und ob der abgelehnte Versuch daran etwas ändert. Den Inhalt der Notiz schreibst Du mir dabei nicht noch einmal hin.

package/bundles/ragents.reference/skills/70-headless-counter/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: 70-headless-counter
+start: true
+disable-model-invocation: true
+title: "Nachrichten ohne KI mitzählen"
+description: "Zeigt einen dauerhaften TypeScript-Actor ohne Oberfläche: Er verarbeitet Nachrichten getrennt und behält Liste und Zähler zwischen Aufträgen."
+category: "TypeScript ohne Oberfläche"
+order: 70
+tags: "Anwendungsfall, Konzeptdemo, TypeScript-Actors, Actor-Funktionen, Actor-Zustand, Journalprüfung"
+---
+
+Ich hätte gern einen kleinen TypeScript-Zähler ohne Oberfläche und ohne KI-Aufrufe. Schicke ihm nacheinander die Texte "eins", "zwei" und "drei". Er soll jeden Text in seiner eigenen Liste behalten und mitzählen. Danach lies seinen Stand aus und belege, dass drei getrennte Eingaben verarbeitet wurden. Der Zähler soll für weitere Texte bereitbleiben.