@schlenkr/ragents 0.1.0 → 0.1.2

package/plugins/ragents.orchestration/web/canvas-scene.ts

@@ -1,311 +0,0 @@
-import {
-  canvasEntityOf,
-  canvasShapeSize,
-  isCanvasGroupNode,
-  type CanvasArrow,
-  type CanvasGroupNode,
-  type CanvasLayout,
-  type CanvasLineStyle,
-  type CanvasShape,
-} from "../contract";
-import type { BoundaryShape, GroupLayout, SceneGroup, SceneLeaf, SceneNode } from "./canvas-layout";
-import type { RunActor, RunView } from "./run-view";
-import { ACTOR_PROGRAMS_STATE_ID, type ActorProgramState } from "@aicontainer/plugins/ragents.actor-programs/contract";
-
-export const DEFAULT_GAP = 44;
-export const RANK_GAP = 86;
-export const TOP_LEVEL_GAP = 56;
-export const ANCHORED_GAP = 20;
-export const AUTO_APP_MAX_COLUMNS = 3;
-export const UNPLACED_LABEL = "Automatisch angeordnet";
-
-export interface SceneApp {
-  key: string;
-  id: string;
-  width: number;
-  height: number;
-  anchorActorId?: string;
-}
-
-export type SceneLeafInfo =
-  | { type: "actor"; actor: RunActor }
-  | { type: "app"; app: SceneApp }
-  | { type: "shape"; shape: CanvasShape }
-  | { type: "missing"; reference: string };
-
-export interface SceneLine {
-  key: string;
-  fromKey: string;
-  toKey: string;
-  label?: string;
-  arrow: CanvasArrow;
-  style: CanvasLineStyle;
-}
-
-export interface Scene {
-  root: SceneGroup;
-  leaves: Map<string, SceneLeafInfo>;
-  lines: SceneLine[];
-  notices: string[];
-}
-
-export interface SceneInput {
-  view: RunView;
-  layout?: CanvasLayout;
-  layoutProblem?: string;
-  actorSize: (actor: RunActor) => { width: number; height: number };
-  apps: readonly SceneApp[];
-  hiddenAppIds?: readonly string[];
-  hiddenActorIds?: readonly string[];
-  showConnections?: boolean;
-}
-
-const ACTOR_KIND_ORDER: Record<string, number> = { human: 0, agent: 1, script: 2 };
-
-export const actorSort = (left: RunActor, right: RunActor) =>
-  (ACTOR_KIND_ORDER[left.kind] ?? 3) - (ACTOR_KIND_ORDER[right.kind] ?? 3)
-  || String(left.createdAt ?? "").localeCompare(String(right.createdAt ?? ""))
-  || left.id.localeCompare(right.id);
-
-export const boundaryOf = (info: SceneLeafInfo): BoundaryShape =>
-  info.type === "shape" ? (info.shape.kind === "circle" ? "circle" : "diamond") : "rect";
-
-const missingSize = (reference: string) => ({
-  width: Math.min(360, Math.max(160, 60 + reference.length * 8)),
-  height: 36,
-});
-
-const isStopped = (actor: RunActor) => actor.lifecycle?.kind === "stopped";
-
-/** Mirrors the server: an active actor wins the handle, otherwise the latest one. */
-const actorsByHandle = (view: RunView): Map<string, RunActor> => {
-  const byHandle = new Map<string, RunActor>();
-  for (const actor of view.actors) {
-    if (actor.kind === "human") continue;
-    const handle = actor.handle.toLowerCase();
-    const current = byHandle.get(handle);
-    if (!current || isStopped(current)) byHandle.set(handle, actor);
-  }
-  return byHandle;
-};
-
-const groupLayoutOf = (node: CanvasGroupNode): GroupLayout => {
-  const gap = node.gap ?? DEFAULT_GAP;
-  switch (node.group) {
-    case "h": return { type: "stack", axis: "h", gap };
-    case "v": return { type: "stack", axis: "v", gap };
-    case "wrap-h": return { type: "wrap", axis: "h", limit: node.width, gap };
-    case "wrap-v": return { type: "wrap", axis: "v", limit: node.height, gap };
-    case "grid": return { type: "grid", columns: node.columns, gap };
-    case "circle": return { type: "circle", gap };
-    case "tree": return { type: "tree", direction: node.direction, rankGap: RANK_GAP, siblingGap: gap };
-  }
-};
-
-export const buildScene = ({ view, layout, layoutProblem, actorSize, apps, hiddenAppIds = [], hiddenActorIds = [], showConnections = true }: SceneInput): Scene => {
-  const hiddenActors = new Set(hiddenActorIds);
-  const hiddenAppReferences = new Set(hiddenAppIds.map((id) => `app:${id}`));
-  const availableAppIds = new Set(apps.map((app) => app.id));
-  const stoppedActorIds = new Set(view.actors.filter(isStopped).map((actor) => actor.id));
-  for (const entry of view.pluginStates) {
-    if (entry.pluginId !== ACTOR_PROGRAMS_STATE_ID || entry.scope.kind !== "actor" || !stoppedActorIds.has(entry.scope.actorId)) continue;
-    const { program } = entry.state as ActorProgramState;
-    for (const app of program?.views ?? []) {
-      if (!availableAppIds.has(app.id)) hiddenAppReferences.add(`app:${app.id}`);
-    }
-  }
-  const notices: string[] = layoutProblem ? [`Layout unlesbar: ${layoutProblem}`] : [];
-  const leaves = new Map<string, SceneLeafInfo>();
-  const cards = view.actors.filter((actor) => actor.kind !== "human").sort(actorSort);
-  const byHandle = actorsByHandle(view);
-  const shapesById = new Map((layout?.shapes ?? []).map((shape) => [shape.id, shape]));
-  const appsById = new Map(apps.map((app) => [app.id, app]));
-  const placedActors = new Set<string>();
-  const placedApps = new Set<string>();
-  const entityKeys = new Map<string, string>();
-
-  const actorLeaf = (actor: RunActor): SceneLeaf => {
-    const key = `actor:${actor.id}`;
-    placedActors.add(actor.id);
-    leaves.set(key, { type: "actor", actor });
-    return { kind: "leaf", key, ...actorSize(actor) };
-  };
-  const appLeaf = (app: SceneApp): SceneLeaf => {
-    placedApps.add(app.key);
-    leaves.set(app.key, { type: "app", app });
-    entityKeys.set(`app:${app.id}`, app.key);
-    return { kind: "leaf", key: app.key, width: app.width, height: app.height };
-  };
-  const shapeLeaf = (shape: CanvasShape): SceneLeaf => {
-    const key = `shape:${shape.id}`;
-    leaves.set(key, { type: "shape", shape });
-    entityKeys.set(key, key);
-    return { kind: "leaf", key, ...canvasShapeSize(shape) };
-  };
-  const missingLeaf = (reference: string, reason: string): SceneLeaf => {
-    const key = `missing:${reference}`;
-    leaves.set(key, { type: "missing", reference });
-    notices.push(reason);
-    return { kind: "leaf", key, ...missingSize(reference) };
-  };
-
-  // Actors and apps named as single items are spoken for before any tree claims its lineage.
-  const claimed = new Set<string>();
-  const claimedApps = new Set<string>();
-  for (const node of layout?.nodes ?? []) {
-    if (isCanvasGroupNode(node)) continue;
-    const entity = canvasEntityOf(node.entity);
-    if (entity.kind === "actor") {
-      const actor = byHandle.get(entity.handle);
-      if (actor) claimed.add(actor.id);
-    } else if (entity.kind === "app") {
-      const app = appsById.get(entity.id);
-      if (app) claimedApps.add(app.key);
-    }
-  }
-
-  const appGroup = (key: string, members: readonly SceneApp[]): SceneGroup => ({
-    kind: "group", key,
-    layout: { type: "grid", columns: Math.min(AUTO_APP_MAX_COLUMNS, Math.ceil(Math.sqrt(members.length))), gap: DEFAULT_GAP },
-    children: members.map(appLeaf),
-  });
-
-  // Apps keep their owner's position even when the owner's card is hidden.
-  const actorWithApps = (actor: RunActor): SceneNode | undefined => {
-    placedActors.add(actor.id);
-    const leaf = hiddenActors.has(actor.id) ? undefined : actorLeaf(actor);
-    const anchored = apps.filter((app) =>
-      app.anchorActorId === actor.id && !claimedApps.has(app.key) && !placedApps.has(app.key));
-    if (anchored.length === 0) return leaf;
-    const group = appGroup(`anchored-apps:${actor.id}`, anchored);
-    return leaf
-      ? { kind: "group", key: `anchored:${actor.id}`, layout: { type: "stack", axis: "v", gap: ANCHORED_GAP }, children: [leaf, group] }
-      : group;
-  };
-
-  const lineageNode = (actor: RunActor, direction: "right" | "down", siblingGap: number): SceneGroup | undefined => {
-    const node = actorWithApps(actor);
-    const children = cards.filter((candidate) =>
-      candidate.createdBy === actor.id && !claimed.has(candidate.id) && !placedActors.has(candidate.id));
-    const descendants = children.flatMap((child) => {
-      const branch = lineageNode(child, direction, siblingGap);
-      return branch ? [branch] : [];
-    });
-    if (!node && descendants.length === 0) return undefined;
-    return {
-      kind: "group",
-      key: `lineage:${actor.id}`,
-      layout: node ? { type: "tree", direction, rankGap: RANK_GAP, siblingGap }
-        : { type: "stack", axis: direction === "right" ? "v" : "h", gap: siblingGap },
-      children: node ? [node, ...descendants] : descendants,
-    };
-  };
-
-  const itemNode = (reference: string): SceneNode | undefined => {
-    const entity = canvasEntityOf(reference);
-    if (entity.kind === "actor") {
-      const actor = byHandle.get(entity.handle);
-      if (!actor) return missingLeaf(reference, `${reference} ist kein Actor dieses Laufs`);
-      if (placedActors.has(actor.id)) return missingLeaf(reference, `${reference} ist schon platziert`);
-      return actorWithApps(actor);
-    }
-    if (entity.kind === "shape") {
-      const shape = shapesById.get(entity.id);
-      return shape ? shapeLeaf(shape) : missingLeaf(reference, `${reference} ist keine definierte Form`);
-    }
-    const app = appsById.get(entity.id);
-    if (!app) return missingLeaf(reference, `${reference} ist keine App auf der Fläche`);
-    if (placedApps.has(app.key)) return missingLeaf(reference, `${reference} ist schon platziert`);
-    return appLeaf(app);
-  };
-
-  const treeChildren = (node: CanvasGroupNode & { group: "tree" }, group: SceneGroup): SceneNode[] => {
-    const entity = canvasEntityOf(node.root);
-    const actor = entity.kind === "actor" ? byHandle.get(entity.handle) : undefined;
-    if (!actor) return [missingLeaf(node.root, `${node.root} ist kein Actor dieses Laufs; der Baum ${node.id} bleibt leer`)];
-    if (placedActors.has(actor.id)) return [missingLeaf(node.root, `${node.root} ist schon platziert; der Baum ${node.id} bleibt leer`)];
-    const tree = lineageNode(actor, node.direction, node.gap ?? DEFAULT_GAP);
-    if (tree) group.layout = tree.layout;
-    return tree?.children ?? [];
-  };
-
-  const groups = new Map<string, SceneGroup>();
-  const topLevel: SceneNode[] = [];
-  for (const node of layout?.nodes ?? []) {
-    if (!isCanvasGroupNode(node)) continue;
-    groups.set(node.id, {
-      kind: "group",
-      key: `group:${node.id}`,
-      layout: groupLayoutOf(node),
-      children: [],
-      ...(node.label || node.frame ? { frame: { label: node.label, outline: node.frame } } : {}),
-    });
-  }
-  for (const node of layout?.nodes ?? []) {
-    const target = node.parent ? groups.get(node.parent)?.children : topLevel;
-    if (!target) continue;
-    if (isCanvasGroupNode(node)) {
-      const group = groups.get(node.id)!;
-      if (node.group === "tree") group.children = treeChildren(node, group);
-      target.push(group);
-    } else {
-      if (!hiddenAppReferences.has(node.entity)) {
-        const item = itemNode(node.entity);
-        if (item) target.push(item);
-      }
-    }
-  }
-
-  const unplaced = cards.filter((actor) => !placedActors.has(actor.id));
-  const unplacedIds = new Set(unplaced.map((actor) => actor.id));
-  const roots = unplaced.filter((actor) => !actor.createdBy || !unplacedIds.has(actor.createdBy));
-  const autoChildren: SceneNode[] = roots
-    .filter((actor) => !placedActors.has(actor.id))
-    .flatMap((actor) => {
-      const branch = lineageNode(actor, "right", DEFAULT_GAP);
-      return branch ? [branch] : [];
-    });
-  const unplacedApps = apps.filter((app) => !placedApps.has(app.key));
-  if (unplacedApps.length > 0) {
-    autoChildren.push(appGroup("auto:apps", unplacedApps));
-  }
-  const removeEmpty = (nodes: SceneNode[]): SceneNode[] => nodes.flatMap<SceneNode>((node) => {
-    if (node.kind === "leaf") return [node];
-    const children = removeEmpty(node.children);
-    return children.length > 0 ? [{ ...node, children }] : [];
-  });
-  const children: SceneNode[] = hiddenActors.size > 0 || hiddenAppReferences.size > 0 ? removeEmpty(topLevel) : [...topLevel];
-  if (autoChildren.length > 0) {
-    children.push(children.length > 0
-      ? { kind: "group", key: "auto", layout: { type: "stack", axis: "v", gap: DEFAULT_GAP }, frame: { label: UNPLACED_LABEL, outline: false }, children: autoChildren }
-      : { kind: "group", key: "auto", layout: { type: "stack", axis: "v", gap: DEFAULT_GAP }, children: autoChildren });
-  }
-
-  for (const [handle, actor] of byHandle) {
-    if (leaves.has(`actor:${actor.id}`)) entityKeys.set(`@${handle}`, `actor:${actor.id}`);
-  }
-
-  const lines = (layout?.lines ?? []).flatMap((line, index): SceneLine[] => {
-    if (!showConnections) return [];
-    if (hiddenAppReferences.has(line.from) || hiddenAppReferences.has(line.to)) return [];
-    if ([line.from, line.to].some((reference) => {
-      const entity = canvasEntityOf(reference);
-      const actor = entity.kind === "actor" ? byHandle.get(entity.handle) : undefined;
-      return actor && hiddenActors.has(actor.id);
-    })) return [];
-    const fromKey = entityKeys.get(line.from);
-    const toKey = entityKeys.get(line.to);
-    if (!fromKey || !toKey) {
-      notices.push(`Linie ${line.from} nach ${line.to}: ${fromKey ? line.to : line.from} ist nicht auf der Fläche`);
-      return [];
-    }
-    return [{ key: `line:${index}`, fromKey, toKey, label: line.label, arrow: line.arrow, style: line.style }];
-  });
-
-  return {
-    root: { kind: "group", key: "root", layout: { type: "stack", axis: "v", gap: TOP_LEVEL_GAP }, children },
-    leaves,
-    lines,
-    notices: [...new Set(notices)],
-  };
-};

package/plugins/ragents.orchestration/web/card-size-settings.ts

@@ -1,36 +0,0 @@
-import { createLocalStorageSetting } from "@aicontainer/web/lib/local-storage-setting";
-
-export interface ActorCardSize { width: number; height: number }
-
-export const DEFAULT_ACTOR_CARD_SIZE: ActorCardSize = { width: 720, height: 520 };
-export const ACTOR_CARD_SIZE_LIMITS = { minWidth: 240, maxWidth: 2880, minHeight: 260, maxHeight: 2700 };
-export const ACTOR_CARD_SIZE_STORAGE_KEY = "ragents.orchestration.actor-card-size";
-
-export function parseActorCardSize(raw: string | null): ActorCardSize {
-  if (raw === null) return DEFAULT_ACTOR_CARD_SIZE;
-  const value: unknown = JSON.parse(raw);
-  if (!value || typeof value !== "object" || !("width" in value) || !("height" in value)
-    || !Number.isInteger(value.width) || !Number.isInteger(value.height)
-    || typeof value.width !== "number" || typeof value.height !== "number"
-    || value.width < ACTOR_CARD_SIZE_LIMITS.minWidth || value.width > ACTOR_CARD_SIZE_LIMITS.maxWidth
-    || value.height < 180 || value.height > ACTOR_CARD_SIZE_LIMITS.maxHeight) {
-    throw new Error("Die Standardgröße der LLM-Karten ist ungültig. Breite: 240 bis 2880, Höhe: 260 bis 2700 Pixel.");
-  }
-  return { width: value.width, height: Math.max(ACTOR_CARD_SIZE_LIMITS.minHeight, value.height) };
-}
-
-const setting = createLocalStorageSetting({
-  changeEvent: "ragents-actor-card-size-change",
-  matchesKey: (key) => key === ACTOR_CARD_SIZE_STORAGE_KEY,
-  parse: parseActorCardSize,
-  serialize: JSON.stringify,
-});
-
-export function useActorCardSize(): ActorCardSize {
-  return setting.useValue(ACTOR_CARD_SIZE_STORAGE_KEY);
-}
-
-export function saveActorCardSize(size: ActorCardSize) {
-  if (size.height < ACTOR_CARD_SIZE_LIMITS.minHeight) throw new Error("LLM-Karten benötigen mindestens 260 Pixel Höhe für Verlauf und Eingabe.");
-  setting.save(ACTOR_CARD_SIZE_STORAGE_KEY, size);
-}

package/plugins/ragents.orchestration/web/keyboard-navigation.ts

@@ -1,55 +0,0 @@
-import type { CanvasCamera } from "./canvas-layout-storage";
-
-const DURATION = 300;
-
-export interface CanvasNavigationBox { id: string; left: number; top: number; right: number; bottom: number }
-
-export const nextCanvasElement = (
-  elements: readonly CanvasNavigationBox[],
-  origin: Omit<CanvasNavigationBox, "id">,
-  key: string,
-  currentId?: string,
-): CanvasNavigationBox | undefined => {
-  if (!["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(key)) return undefined;
-  const horizontal = key === "ArrowLeft" || key === "ArrowRight";
-  const direction = key === "ArrowLeft" || key === "ArrowUp" ? -1 : 1;
-  const x = (origin.left + origin.right) / 2;
-  const y = (origin.top + origin.bottom) / 2;
-  return elements.filter((box) => box.id !== currentId).map((box) => {
-    const dx = (box.left + box.right) / 2 - x;
-    const dy = (box.top + box.bottom) / 2 - y;
-    const forward = (horizontal ? dx : dy) * direction;
-    const across = horizontal ? dy : dx;
-    const aligned = horizontal ? box.bottom >= origin.top && box.top <= origin.bottom
-      : box.right >= origin.left && box.left <= origin.right;
-    return { box, forward, aligned, distance: Math.hypot(forward, across * 2) };
-  }).filter((entry) => entry.forward > 1)
-    .sort((a, b) => Number(b.aligned) - Number(a.aligned) || a.distance - b.distance || a.box.id.localeCompare(b.box.id))[0]?.box;
-};
-
-export const createKeyboardNavigation = (read: () => CanvasCamera, apply: (camera: CanvasCamera) => void) => {
-  let frame: number | undefined;
-  let startedAt = -Infinity;
-  const cancel = () => {
-    if (frame !== undefined) cancelAnimationFrame(frame);
-    frame = undefined;
-  };
-  const moveTo = (to: CanvasCamera, repeat: boolean, reducedMotion: boolean): boolean => {
-    const now = performance.now();
-    if (repeat && (frame !== undefined || now - startedAt < DURATION)) return false;
-    const from = read();
-    cancel();
-    startedAt = now;
-    if (reducedMotion) { apply(to); return true; }
-    const step = (time: number) => {
-      const progress = Math.min(1, Math.max(0, (time - startedAt) / DURATION));
-      const eased = progress * progress * (3 - 2 * progress);
-      apply({ x: from.x + (to.x - from.x) * eased, y: from.y + (to.y - from.y) * eased, zoom: from.zoom });
-      if (progress < 1) frame = requestAnimationFrame(step);
-      else frame = undefined;
-    };
-    frame = requestAnimationFrame(step);
-    return true;
-  };
-  return { moveTo, cancel };
-};

package/plugins/ragents.orchestration/web/material-layout.ts

@@ -1,14 +0,0 @@
-import type { SceneNode } from "./canvas-layout";
-
-export function withMaterialSpacing(node: SceneNode, depth: number): SceneNode {
-  if (node.kind === "leaf") return node;
-  const horizontal = depth * .5 + 32, vertical = depth * .7 + 32;
-  const layout = node.layout;
-  const next = layout.type === "tree" ? {
-    ...layout,
-    rankGap: Math.max(layout.rankGap, layout.direction === "right" ? horizontal : vertical),
-    siblingGap: Math.max(layout.siblingGap, layout.direction === "right" ? vertical : horizontal),
-  } : { ...layout, gap: Math.max(layout.gap,
-    layout.type === "stack" ? layout.axis === "h" ? horizontal : vertical : Math.max(horizontal, vertical)) };
-  return { ...node, layout: next, children: node.children.map((child) => withMaterialSpacing(child, depth)) };
-}

package/plugins/ragents.orchestration/web/useCanvasMeasurements.ts

@@ -1,78 +0,0 @@
-import { useCallback, useLayoutEffect, useRef, useState, type RefCallback } from "react";
-
-export interface CanvasSize {
-  width: number;
-  height: number;
-}
-
-type MeasuredElement = HTMLElement | SVGGraphicsElement;
-
-export function useCanvasMeasurements() {
-  const [sizes, setSizes] = useState<ReadonlyMap<string, CanvasSize>>(new Map());
-  const elements = useRef(new Map<string, MeasuredElement>());
-  const callbacks = useRef(new Map<string, RefCallback<MeasuredElement>>());
-  const observer = useRef<ResizeObserver | null>(null);
-  const frame = useRef<number | null>(null);
-
-  const measure = useCallback(() => {
-    frame.current = null;
-    const measured = new Map<string, CanvasSize>();
-    for (const [key, element] of elements.current) {
-      // Layout dimensions remain in world coordinates, independent of camera transforms.
-      const size = element instanceof SVGGraphicsElement ? element.getBBox() : { width: element.offsetWidth, height: element.offsetHeight };
-      const { width, height } = size;
-      if (element.isConnected && width > 0 && height > 0) measured.set(key, { width, height });
-    }
-    const keys = new Set(elements.current.keys());
-    for (const key of callbacks.current.keys()) if (!keys.has(key)) callbacks.current.delete(key);
-    setSizes((previous) => {
-      const next = new Map<string, CanvasSize>();
-      for (const key of keys) {
-        const size = measured.get(key) ?? previous.get(key);
-        if (size) next.set(key, size);
-      }
-      const changed = next.size !== previous.size || [...next].some(([key, size]) => {
-        const before = previous.get(key);
-        return !before || before.width !== size.width || before.height !== size.height;
-      });
-      return changed ? next : previous;
-    });
-  }, []);
-
-  const schedule = useCallback(() => {
-    if (observer.current && frame.current === null) frame.current = requestAnimationFrame(measure);
-  }, [measure]);
-
-  const refFor = useCallback((key: string): RefCallback<MeasuredElement> => {
-    let callback = callbacks.current.get(key);
-    if (!callback) {
-      callback = (element) => {
-        const previous = elements.current.get(key);
-        if (previous === element) return;
-        if (previous) observer.current?.unobserve(previous);
-        if (element) {
-          elements.current.set(key, element);
-          observer.current?.observe(element, { box: "border-box" });
-        } else elements.current.delete(key);
-        schedule();
-      };
-      callbacks.current.set(key, callback);
-    }
-    return callback;
-  }, [schedule]);
-
-  useLayoutEffect(() => {
-    const active = new ResizeObserver(schedule);
-    observer.current = active;
-    for (const element of elements.current.values()) active.observe(element, { box: "border-box" });
-    measure();
-    return () => {
-      active.disconnect();
-      observer.current = null;
-      if (frame.current !== null) cancelAnimationFrame(frame.current);
-      frame.current = null;
-    };
-  }, [measure, schedule]);
-
-  return { sizes, refFor };
-}

package/plugins/ragents.orchestration/web/zoom-settings.ts

@@ -1,28 +0,0 @@
-import { createLocalStorageSetting } from "@aicontainer/web/lib/local-storage-setting";
-
-export const DEFAULT_PINCH_ZOOM_SENSITIVITY = 2;
-export const PINCH_ZOOM_STORAGE_KEY = "ragents.orchestration.pinch-zoom-sensitivity";
-
-export function parsePinchZoomSensitivity(raw: string | null): number {
-  if (raw === null) return DEFAULT_PINCH_ZOOM_SENSITIVITY;
-  const value = Number(raw);
-  if (!Number.isFinite(value) || value < 0.1 || value > 10) {
-    throw new Error("Die Pinch-Zoom-Empfindlichkeit muss zwischen 0,1 und 10 liegen.");
-  }
-  return value;
-}
-
-const setting = createLocalStorageSetting({
-  changeEvent: "ragents-pinch-zoom-change",
-  matchesKey: (key) => key === PINCH_ZOOM_STORAGE_KEY,
-  parse: parsePinchZoomSensitivity,
-  serialize: String,
-});
-
-export function usePinchZoomSensitivity(): number {
-  return setting.useValue(PINCH_ZOOM_STORAGE_KEY);
-}
-
-export function savePinchZoomSensitivity(value: number) {
-  setting.save(PINCH_ZOOM_STORAGE_KEY, value);
-}

package/plugins/ragents.reference/skills/120-canvas-conversation-circle/SKILL.md

@@ -1,12 +0,0 @@
----
-name: 120-canvas-conversation-circle
-start: true
-disable-model-invocation: true
-title: "Eine Gesprächsrunde auf der Fläche anordnen"
-description: "Zeigt beim Aufbau einer Gesprächsrunde, wie Actors, ein Thema und die Übergaben auf der Arbeitsfläche angeordnet werden."
-category: "Zusammenarbeit"
-order: 120
-tags: "Anwendungsfall, Konzeptdemo, Agententeams, Canvas-Layout"
----
-
-Ich hätte gern drei KIs mit eigenen Namen und Charakteren, die sich reihum zu einem Thema Deiner Wahl unterhalten, zwei Runden lang, jede mit einem kurzen Satz. Bevor es losgeht, will ich den Aufbau auf der Fläche neben dem Chat sehen: die drei im Kreis, das Thema als Raute darüber und Pfeile, die zeigen, wer an wen weitergibt. Am Ende fasst Du mir das Gespräch in drei Sätzen zusammen.

package/plugins/ragents.reference/skills/130-canvas-pipeline-with-approval/SKILL.md

@@ -1,12 +0,0 @@
----
-name: 130-canvas-pipeline-with-approval
-start: true
-disable-model-invocation: true
-title: "Arbeitsschritte mit Freigabe verbinden"
-description: "Zeigt drei Agenten als aufeinanderfolgende Arbeitsschritte mit beschrifteten Übergaben und einer grafisch dargestellten Freigabefrage."
-category: "Ereignisse und Abläufe"
-order: 130
-tags: "Anwendungsfall, Konzeptdemo, Agententeams, Canvas-Layout"
----
-
-Ich hätte gern drei KIs, die wie an einem Fließband arbeiten: die erste sammelt Stichpunkte zu einem Thema Deiner Wahl, die zweite schreibt daraus einen kurzen Absatz, die dritte poliert ihn. Auf der Fläche neben dem Chat will ich die drei in einer Reihe sehen, mit beschrifteten Pfeilen dazwischen, und am Ende eine Raute mit der Frage, ob der Text freigegeben wird. Zeig mir zum Schluss den fertigen Absatz.

package/plugins/ragents.reference/skills/140-canvas-team-tree-and-topic-grid/SKILL.md

@@ -1,12 +0,0 @@
----
-name: 140-canvas-team-tree-and-topic-grid
-start: true
-disable-model-invocation: true
-title: "Ein Team und seine Themen anordnen"
-description: "Zeigt Hierarchien, Themengruppen und Zuständigkeiten auf der Arbeitsfläche sowie die automatische Platzierung eines zusätzlichen Beobachters."
-category: "Zusammenarbeit"
-order: 140
-tags: "Konzeptdemo, Agententeams, Canvas-Layout"
----
-
-Ich hätte gern einen Teamleiter, der sich drei Helfer holt und jedem ein Thema Deiner Wahl gibt; jeder Helfer liefert drei Stichpunkte. Dazu einen Beobachter, der am Ende alles in zwei Sätzen bewertet. Auf der Fläche neben dem Chat will ich das Team als Baum sehen, daneben vier Themen als Kreise in zwei Spalten und gestrichelte Linien von jedem Helfer zu seinem Thema; das vierte bleibt frei. Den Beobachter ordne nicht selbst ein.