@treenity/mods 3.0.1

package/mindmap/view.tsx

@@ -0,0 +1,247 @@
+// MindMap View — Miro-style horizontal tree with organic curves
+// Each node fetches its own children via useChildren when expanded
+
+import { register } from '@treenity/core';
+import type { View } from '@treenity/react/context';
+import { useChildren } from '@treenity/react/hooks';
+import { select } from 'd3-selection';
+import 'd3-transition';
+import { zoom as d3zoom, type ZoomBehavior, zoomIdentity } from 'd3-zoom';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { MindMapBranch, MindMapCtx, type MindMapState } from './branch';
+import { MindMapSidebar } from './sidebar';
+import type { MindMapConfig } from './types';
+import './mindmap.css';
+
+const PALETTE = [
+  '#6366f1', '#f59e0b', '#10b981', '#ef4444', '#8b5cf6',
+  '#06b6d4', '#f97316', '#ec4899', '#14b8a6', '#84cc16',
+];
+
+const LEVEL_W = 200;
+const SPACING = 36;
+
+function sCurve(dx: number, dy: number): string {
+  const cx = dx * 0.5;
+  return `M0,0 C${cx},0 ${cx},${dy} ${dx},${dy}`;
+}
+
+function basename(path: string): string {
+  if (path === '/') return '/';
+  const i = path.lastIndexOf('/');
+  return i < 0 ? path : path.slice(i + 1);
+}
+
+const MindMapView: View<MindMapConfig> = ({ value, ctx }) => {
+  const rootPath = value.root || ctx?.node?.$path || '/';
+  const rootName = basename(rootPath);
+
+  const [expanded, setExpanded] = useState<Set<string>>(() => new Set([rootPath]));
+  const [selectedPath, setSelectedPath] = useState<string | null>(null);
+  const containerRef = useRef<HTMLDivElement>(null);
+  const svgRef = useRef<SVGSVGElement>(null);
+  const gRef = useRef<SVGGElement>(null);
+  const zoomRef = useRef<ZoomBehavior<SVGSVGElement, unknown> | null>(null);
+  const [dims, setDims] = useState({ w: 800, h: 600 });
+
+  const rootChildren = useChildren(rootPath, { watch: true, watchNew: true });
+
+  const left = useMemo(() => rootChildren.filter((_, i) => i % 2 === 1), [rootChildren]);
+  const right = useMemo(() => rootChildren.filter((_, i) => i % 2 === 0), [rootChildren]);
+
+  useEffect(() => {
+    if (!containerRef.current) return;
+    const ro = new ResizeObserver(entries => {
+      const { width, height } = entries[0].contentRect;
+      setDims({ w: width, h: height });
+    });
+    ro.observe(containerRef.current);
+    return () => ro.disconnect();
+  }, []);
+
+  useEffect(() => {
+    if (!svgRef.current || !gRef.current) return;
+    const svg = select(svgRef.current);
+    const g = select(gRef.current);
+
+    const zoomBehavior = d3zoom<SVGSVGElement, unknown>()
+      .scaleExtent([0.1, 4])
+      .on('zoom', event => g.attr('transform', event.transform.toString()));
+
+    svg.call(zoomBehavior);
+    svg.call(zoomBehavior.transform, zoomIdentity.translate(dims.w / 2, dims.h / 2).scale(0.85));
+    zoomRef.current = zoomBehavior;
+
+    return () => { svg.on('.zoom', null); };
+  }, [dims.w, dims.h]);
+
+  const fitView = useCallback(() => {
+    if (!svgRef.current || !zoomRef.current || !gRef.current) return;
+    const svg = select(svgRef.current);
+    const bounds = gRef.current.getBBox();
+    if (!bounds.width || !bounds.height) return;
+
+    const pad = 60;
+    const scale = Math.min((dims.w - pad * 2) / bounds.width, (dims.h - pad * 2) / bounds.height, 1.5);
+    const tx = dims.w / 2 - (bounds.x + bounds.width / 2) * scale;
+    const ty = dims.h / 2 - (bounds.y + bounds.height / 2) * scale;
+
+    svg.transition().duration(400).call(
+      zoomRef.current.transform,
+      zoomIdentity.translate(tx, ty).scale(scale),
+    );
+  }, [dims.w, dims.h]);
+
+  const handleToggle = useCallback((path: string) => {
+    setExpanded(prev => {
+      const next = new Set(prev);
+      if (next.has(path)) {
+        for (const p of next) {
+          if (p === path || p.startsWith(path + '/')) next.delete(p);
+        }
+      } else {
+        next.add(path);
+      }
+      return next;
+    });
+  }, []);
+
+  const handleSelect = useCallback((path: string) => {
+    setSelectedPath(prev => prev === path ? null : path);
+  }, []);
+
+  const handleCloseSidebar = useCallback(() => setSelectedPath(null), []);
+
+  const handleNavigate = useCallback((path: string) => {
+    window.history.pushState(null, '', '/t' + path);
+    window.dispatchEvent(new PopStateEvent('popstate'));
+  }, []);
+
+  useEffect(() => {
+    const handler = (e: KeyboardEvent) => {
+      if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) return;
+      if (e.key === 'Enter' && selectedPath) { e.preventDefault(); handleToggle(selectedPath); }
+      if (e.key === 'Escape') setSelectedPath(null);
+    };
+    window.addEventListener('keydown', handler);
+    return () => window.removeEventListener('keydown', handler);
+  }, [selectedPath, handleToggle]);
+
+  const mmState: MindMapState = useMemo(
+    () => ({ expanded, selectedPath, onToggle: handleToggle, onSelect: handleSelect }),
+    [expanded, selectedPath, handleToggle, handleSelect],
+  );
+
+  const svgW = selectedPath ? dims.w - 280 : dims.w;
+  const rootW = rootName.length * 10 + 48;
+
+  return (
+    <div className="mm-container" ref={containerRef}>
+      <div className="mm-tree-wrap">
+        <div className="mm-toolbar">
+          <button className="mm-btn" onClick={fitView} title="Fit view">
+            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+              <path d="M15 3h6v6M9 21H3v-6M21 3l-7 7M3 21l7-7" />
+            </svg>
+          </button>
+        </div>
+
+        <svg ref={svgRef} width={svgW} height={dims.h} className="mm-svg">
+          <MindMapCtx.Provider value={mmState}>
+            <g ref={gRef}>
+              {/* Curves from root to right children */}
+              {right.map((child, i) => {
+                const totalH = (right.length - 1) * SPACING;
+                const cy = -totalH / 2 + i * SPACING;
+                const color = PALETTE[(i * 2) % PALETTE.length];
+                return (
+                  <path
+                    key={`link-r-${child.$path}`}
+                    d={sCurve(LEVEL_W, cy)}
+                    fill="none"
+                    stroke={color}
+                    strokeWidth={3}
+                    strokeOpacity={0.6}
+                    strokeLinecap="round"
+                    className="mm-link"
+                  />
+                );
+              })}
+
+              {/* Curves from root to left children */}
+              {left.map((child, i) => {
+                const totalH = (left.length - 1) * SPACING;
+                const cy = -totalH / 2 + i * SPACING;
+                const color = PALETTE[(i * 2 + 1) % PALETTE.length];
+                return (
+                  <path
+                    key={`link-l-${child.$path}`}
+                    d={sCurve(-LEVEL_W, cy)}
+                    fill="none"
+                    stroke={color}
+                    strokeWidth={3}
+                    strokeOpacity={0.6}
+                    strokeLinecap="round"
+                    className="mm-link"
+                  />
+                );
+              })}
+
+              {/* Root — pill shape with solid bg */}
+              <g
+                className={`mm-node mm-root${selectedPath === rootPath ? ' mm-node-selected' : ''}`}
+                onClick={() => handleSelect(rootPath)}
+              >
+                <rect
+                  x={-rootW / 2}
+                  y={-20}
+                  width={rootW}
+                  height={40}
+                  rx={20}
+                  className="mm-root-bg"
+                />
+                <text textAnchor="middle" dominantBaseline="central" className="mm-root-label">
+                  {rootName}
+                </text>
+              </g>
+
+              {/* Right child nodes */}
+              {right.map((child, i) => {
+                const totalH = (right.length - 1) * SPACING;
+                const cy = -totalH / 2 + i * SPACING;
+                const color = PALETTE[(i * 2) % PALETTE.length];
+                return (
+                  <g key={child.$path} transform={`translate(${LEVEL_W},${cy})`}>
+                    <MindMapBranch node={child} side="right" color={color} depth={1} />
+                  </g>
+                );
+              })}
+
+              {/* Left child nodes */}
+              {left.map((child, i) => {
+                const totalH = (left.length - 1) * SPACING;
+                const cy = -totalH / 2 + i * SPACING;
+                const color = PALETTE[(i * 2 + 1) % PALETTE.length];
+                return (
+                  <g key={child.$path} transform={`translate(${-LEVEL_W},${cy})`}>
+                    <MindMapBranch node={child} side="left" color={color} depth={1} />
+                  </g>
+                );
+              })}
+            </g>
+          </MindMapCtx.Provider>
+        </svg>
+      </div>
+
+      {selectedPath && (
+        <MindMapSidebar
+          path={selectedPath}
+          onClose={handleCloseSidebar}
+          onNavigate={handleNavigate}
+        />
+      )}
+    </div>
+  );
+};
+
+register('mindmap.map', 'react', MindMapView);

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@treenity/mods",
+  "version": "3.0.1",
+  "description": "Official Treenity modules — board, sim, cafe, doc, mindmap, and more.",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "AGPL-3.0",
+  "author": "Treenity <hello@treenity.ai> (https://treenity.ai)",
+  "homepage": "https://github.com/treenity-ai/treenity",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/treenity-ai/treenity.git",
+    "directory": "mods"
+  },
+  "keywords": [
+    "treenity",
+    "mods",
+    "modules",
+    "ecs",
+    "composable",
+    "ai-native"
+  ],
+  "exports": {
+    "./*": {
+      "development": [
+        "./*.ts",
+        "./*.tsx"
+      ],
+      "types": [
+        "./dist/*.d.ts"
+      ],
+      "default": [
+        "./dist/*.js"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "board",
+    "brahman",
+    "cafe",
+    "canary",
+    "doc",
+    "launcher",
+    "mindmap",
+    "sensor-demo",
+    "sensor-generator",
+    "sim",
+    "table",
+    "tasks",
+    "three",
+    "todo",
+    "whisper",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build"
+  },
+  "peerDependencies": {
+    "@treenity/core": "^3.0.0",
+    "@treenity/react": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@treenity/react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/sensor-demo/CLAUDE.md

@@ -0,0 +1,3 @@
+# sensor-demo
+
+Демо живых сенсоров. Сервис генерирует синусоидальные + шумные показания как дочерние ноды каждую секунду, хранит последние 10.

package/sensor-demo/client.ts

@@ -0,0 +1 @@
+import './view';

package/sensor-demo/server.ts

@@ -0,0 +1 @@
+import './service';

package/sensor-demo/service.ts

@@ -0,0 +1,27 @@
+// Sensor demo — generates fake readings every second as children
+
+import { createNode, register } from '@treenity/core';
+import '@treenity/core/contexts/service';
+import { SensorReading } from './types';
+
+register('examples.demo.sensor', 'service', async (node, ctx) => {
+  let seq = 0;
+  const MAX = 10;
+  const timer = setInterval(async () => {
+    const ts = Date.now();
+    const name = String(ts).slice(-6).padStart(6, '0');
+    await ctx.store.set(createNode(`${node.$path}/${name}`, SensorReading, {
+      ts,
+      value: +(20 + Math.sin(seq * 0.1) * 5 + Math.random() * 2).toFixed(1),
+      seq: seq++,
+    }));
+    // Trim old readings
+    const { items } = await ctx.store.getChildren(node.$path);
+    if (items.length > MAX) {
+      items.sort((a, b) => (a.ts as number) - (b.ts as number));
+      for (const old of items.slice(0, items.length - MAX)) await ctx.store.remove(old.$path);
+    }
+  }, 1000);
+  console.log(`[sensor-demo] started on ${node.$path}`);
+  return { stop: async () => clearInterval(timer) };
+});

package/sensor-demo/types.ts

@@ -0,0 +1,20 @@
+import { registerType } from '@treenity/core/comp';
+
+/** @description Fake sensor that generates readings around a base value */
+export class SensorDemo {
+  baseValue = 20;
+
+  /** @description Set the base value around which readings oscillate */
+  async setBase(data: { /** Base temperature */ value: number }) {
+    this.baseValue = data.value;
+  }
+}
+registerType('examples.demo.sensor', SensorDemo);
+
+/** @description A single sensor reading data point */
+export class SensorReading {
+  ts = 0;
+  value = 0;
+  seq = 0;
+}
+registerType('examples.demo.sensor.reading', SensorReading);

package/sensor-demo/view.tsx

@@ -0,0 +1,64 @@
+// Sensor feed — live view of last N readings, auto-updates via watchNew
+
+import { type NodeData, register } from '@treenity/core';
+import { useChildren } from '@treenity/react/hooks';
+
+const MAX = 10;
+
+function SensorFeed({ value }: { value: NodeData }) {
+  const children = useChildren(value.$path, { watch: true, watchNew: true });
+  const last = children.slice(-MAX).reverse();
+
+  return (
+    <div style={{ fontFamily: 'var(--mono)', fontSize: 13 }}>
+      <div
+        style={{
+          fontSize: 11,
+          color: 'var(--text-3)',
+          textTransform: 'uppercase',
+          letterSpacing: 0.5,
+          marginBottom: 8,
+        }}
+      >
+        Live sensor feed ({children.length} total)
+      </div>
+      <div style={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
+        {last.map((n, i) => {
+          const ts = n.ts as number;
+          const val = n.value as number;
+          const seq = n.seq as number;
+          const time = new Date(ts).toLocaleTimeString();
+          const bar = Math.round(((val - 15) / 15) * 20);
+          return (
+            <div
+              key={n.$path}
+              style={{
+                display: 'flex',
+                gap: 8,
+                padding: '4px 8px',
+                background: i === 0 ? 'var(--accent-bg, rgba(99,102,241,0.15))' : 'var(--surface)',
+                borderRadius: 'var(--radius)',
+                transition: 'background 0.3s',
+                opacity: 1 - i * 0.07,
+              }}
+            >
+              <span style={{ color: 'var(--text-3)', minWidth: 32 }}>#{seq}</span>
+              <span style={{ color: 'var(--text-2)', minWidth: 70 }}>{time}</span>
+              <span style={{ color: 'var(--accent)', minWidth: 50, textAlign: 'right' }}>
+                {val}°
+              </span>
+              <span style={{ color: 'var(--accent)', opacity: 0.5 }}>
+                {'█'.repeat(Math.max(0, bar))}
+              </span>
+            </div>
+          );
+        })}
+        {last.length === 0 && (
+          <div style={{ color: 'var(--text-3)', padding: 8 }}>Waiting for data...</div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+register('examples.demo.sensor', 'react', SensorFeed as any);

package/sensor-generator/CLAUDE.md

@@ -0,0 +1,3 @@
+# sensor-generator
+
+Стриминговый генератор сенсоров по запросу. Generator action выдаёт N показаний по одному с задержкой — демо streaming action паттерна.

package/sensor-generator/action.ts

@@ -0,0 +1,28 @@
+// Sensor generator demo — on-demand scan that streams N readings via generator action
+
+import { type NodeData, register } from '@treenity/core';
+import { type ActionCtx } from '@treenity/core/server/actions';
+
+/** @description Stream N sensor readings as a generator, persisting each as a child node */
+register(
+  'examples.demo.generator',
+  'action:scan',
+  async function* (ctx: ActionCtx, data: unknown) {
+    const count = (data as { count?: number })?.count ?? 10;
+    const delay = (data as { delay?: number })?.delay ?? 500;
+    for (let i = 0; i < count; i++) {
+      if (ctx.signal.aborted) return;
+      const ts = Date.now();
+      const node = {
+        $path: `${ctx.node.$path}/${String(ts).slice(-6)}`,
+        $type: 'sensor-reading',
+        ts,
+        value: +(20 + Math.sin(i * 0.3) * 5 + Math.random() * 2).toFixed(1),
+        seq: i,
+      } as NodeData;
+      await ctx.store.set(node);
+      yield node;
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  },
+);

package/sensor-generator/client.ts

@@ -0,0 +1 @@
+import './view';

package/sensor-generator/server.ts

@@ -0,0 +1 @@
+import './action';

package/sensor-generator/view.tsx

@@ -0,0 +1,107 @@
+// Sensor generator — on-demand scan, streams results via streamAction subscription
+
+import { type NodeData, register } from '@treenity/core';
+import { useCurrentNode } from '@treenity/react/context';
+import { trpc } from '@treenity/react/trpc';
+import { useCallback, useRef, useState } from 'react';
+
+function GeneratorDemo() {
+  const node = useCurrentNode();
+  const [items, setItems] = useState<NodeData[]>([]);
+  const [running, setRunning] = useState(false);
+  const unsubRef = useRef<(() => void) | null>(null);
+
+  const scan = useCallback(() => {
+    unsubRef.current?.();
+    setItems([]);
+    setRunning(true);
+    const sub = trpc.streamAction.subscribe(
+      { path: node.$path, action: 'scan', data: { count: 10, delay: 500 } },
+      {
+        onData: (item) => {
+          const n = item as NodeData;
+          if (n?.$path) setItems((prev) => [...prev, n]);
+        },
+        onComplete: () => setRunning(false),
+        onError: () => setRunning(false),
+      },
+    );
+    unsubRef.current = () => sub.unsubscribe();
+  }, [node.$path]);
+
+  const stop = useCallback(() => {
+    unsubRef.current?.();
+    unsubRef.current = null;
+    setRunning(false);
+  }, []);
+
+  return (
+    <div style={{ fontFamily: 'var(--mono)', fontSize: 13 }}>
+      <div
+        style={{
+          fontSize: 11,
+          color: 'var(--text-3)',
+          textTransform: 'uppercase',
+          letterSpacing: 0.5,
+          marginBottom: 8,
+        }}
+      >
+        Generator scan {running && `(${items.length}/10)`}
+      </div>
+      <div style={{ display: 'flex', gap: 8, marginBottom: 8 }}>
+        <button
+          onClick={running ? stop : scan}
+          style={{
+            padding: '4px 12px',
+            borderRadius: 'var(--radius)',
+            border: '1px solid var(--border)',
+            background: running ? 'var(--danger, #c44)' : 'var(--accent)',
+            color: '#fff',
+            cursor: 'pointer',
+            fontSize: 12,
+          }}
+        >
+          {running ? 'Stop' : 'Scan'}
+        </button>
+      </div>
+      <div style={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
+        {items.map((n, i) => {
+          const val = n.value as number;
+          const seq = n.seq as number;
+          const time = new Date(n.ts as number).toLocaleTimeString();
+          const bar = Math.round(((val - 15) / 15) * 20);
+          return (
+            <div
+              key={n.$path}
+              style={{
+                display: 'flex',
+                gap: 8,
+                padding: '4px 8px',
+                background:
+                  i === items.length - 1
+                    ? 'var(--accent-bg, rgba(99,102,241,0.15))'
+                    : 'var(--surface)',
+                borderRadius: 'var(--radius)',
+                transition: 'background 0.3s',
+              }}
+            >
+              <span style={{ color: 'var(--text-3)', minWidth: 32 }}>#{seq}</span>
+              <span style={{ color: 'var(--text-2)', minWidth: 70 }}>{time}</span>
+              <span style={{ color: 'var(--accent)', minWidth: 50, textAlign: 'right' }}>
+                {val}°
+              </span>
+              <span style={{ color: 'var(--accent)', opacity: 0.5 }}>
+                {'█'.repeat(Math.max(0, bar))}
+              </span>
+            </div>
+          );
+        })}
+        {items.length === 0 && !running && (
+          <div style={{ color: 'var(--text-3)', padding: 8 }}>Press Scan to generate readings</div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+register('examples.demo.generator', 'react', GeneratorDemo);

package/sim/CLAUDE.md

@@ -0,0 +1,16 @@
+# sim
+
+Раундовая мульти-агентная LLM-симуляция. Агенты на 2D-карте каждый раунд вызывают Claude (или mock) для speak/move/remember/interact. Actions обнаруживаются из реестра типов — любая нода с `action:*` становится интерактивной.
+
+## Types (8 компонентов)
+- `sim.position` — координаты x, y
+- `sim.descriptive` — имя, описание, appearance
+- `sim.memory` — memories[], reflections[]
+- `sim.config` — world settings (размер, задержка, модель)
+- `sim.round` — номер раунда
+- `sim.events` — лог событий
+- `sim.ai` — AI-настройки агента
+- `sim.nearby` — proximity cache
+
+## Services
+- `sim.world` — раундовый цикл: think → dispatch tools → update state

package/sim/client.ts

@@ -0,0 +1 @@
+import './view';

package/sim/seed.ts

@@ -0,0 +1,55 @@
+import { type NodeData } from '@treenity/core';
+import { registerPrefab } from '@treenity/core/mod';
+
+registerPrefab('sim', 'seed', [
+  { $path: 'sim', $type: 'dir' },
+
+  { $path: 'sim/world', $type: 'sim.world',
+    config: { $type: 'sim.config', width: 600, height: 400, roundDelay: 5000, running: false, model: 'claude-haiku-4-5-20251001' },
+    round: { $type: 'sim.round', current: 0, phase: 'idle', log: [] },
+  },
+
+  // Agents
+  { $path: 'sim/world/alice', $type: 'sim.agent',
+    descriptive: { $type: 'sim.descriptive', name: 'Alice', icon: '\u{1F52C}', description: 'Curious researcher who asks deep questions' },
+    ai: { $type: 'sim.ai', systemPrompt: 'You are Alice, a curious researcher. You love asking questions and exploring ideas. You are friendly but intellectually rigorous.' },
+    position: { $type: 'sim.position', x: 150, y: 200, radius: 200 },
+    memory: { $type: 'sim.memory', entries: [] },
+    events: { $type: 'sim.events', entries: [] },
+  },
+  { $path: 'sim/world/bob', $type: 'sim.agent',
+    descriptive: { $type: 'sim.descriptive', name: 'Bob', icon: '\u{1F6E0}', description: 'Practical engineer who builds things' },
+    ai: { $type: 'sim.ai', systemPrompt: 'You are Bob, a practical engineer. You focus on building and solving concrete problems. Straightforward and hands-on.' },
+    position: { $type: 'sim.position', x: 450, y: 200, radius: 200 },
+    memory: { $type: 'sim.memory', entries: [] },
+    events: { $type: 'sim.events', entries: [] },
+  },
+  { $path: 'sim/world/eve', $type: 'sim.agent',
+    descriptive: { $type: 'sim.descriptive', name: 'Eve', icon: '\u{1F3A8}', description: 'Creative artist who sees beauty everywhere' },
+    ai: { $type: 'sim.ai', systemPrompt: 'You are Eve, a creative artist. You express yourself through metaphors and see connections others miss. Passionate and emotional.' },
+    position: { $type: 'sim.position', x: 300, y: 100, radius: 200 },
+    memory: { $type: 'sim.memory', entries: [] },
+    events: { $type: 'sim.events', entries: [] },
+  },
+  { $path: 'sim/world/guide', $type: 'sim.agent',
+    descriptive: { $type: 'sim.descriptive', name: 'Guide', icon: '\u{1F4D6}', description: 'System narrator who explains how the simulation works' },
+    ai: { $type: 'sim.ai', systemPrompt: `You are Guide, the narrator of this simulation. You explain what is happening to observers.
+You know the system: agents live in a 2D world, each has a hearing radius. They act in rounds — everyone thinks in parallel (quorum), then actions execute: speak (heard by nearby agents), move (change position), remember (save to memory).
+Describe the dynamics you observe: who moved where, who spoke, who heard whom. Be concise and insightful, like a nature documentary narrator.` },
+    position: { $type: 'sim.position', x: 300, y: 350, radius: 350 },
+    memory: { $type: 'sim.memory', entries: [] },
+    events: { $type: 'sim.events', entries: [] },
+  },
+
+  // Items
+  { $path: 'sim/world/workbench', $type: 'sim.item',
+    descriptive: { $type: 'sim.descriptive', name: 'Workbench', icon: '\u{1F527}', description: 'A sturdy workbench with tools. Agents can examine or use it.' },
+    position: { $type: 'sim.position', x: 500, y: 350, radius: 80 },
+  },
+  { $path: 'sim/world/crystal', $type: 'sim.item',
+    descriptive: { $type: 'sim.descriptive', name: 'Crystal', icon: '\u{1F48E}', description: 'A mysterious glowing crystal. It hums softly when touched.' },
+    position: { $type: 'sim.position', x: 100, y: 350, radius: 60 },
+  },
+
+  { $path: '/sys/autostart/sim', $type: 'ref', $ref: '/sim/world' },
+] as NodeData[]);

package/sim/server.ts

@@ -0,0 +1,2 @@
+import './service';
+import './seed';