@polderlabs/bizar 4.7.2 → 4.9.0

package/bizar-dash/tests/docker-build.test.mjs

@@ -0,0 +1,96 @@
+/**
+ * bizar-dash/tests/docker-build.test.mjs
+ *
+ * v4.9.0 — Validate Docker deployment configuration files.
+ *
+ * Checks:
+ *   - Dockerfile exists and has valid syntax (FROM, CMD/ENTRYPOINT, EXPOSE, HEALTHCHECK)
+ *   - docker-compose.yml exists with bizar-dash service and ports
+ *   - .dockerignore exists
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..', '..');
+
+const DOCKERFILE = join(ROOT, 'Dockerfile');
+const COMPOSE_FILE = join(ROOT, 'docker-compose.yml');
+const DOCKERIGNORE = join(ROOT, '.dockerignore');
+
+// ── Dockerfile ──────────────────────────────────────────────────────────────
+
+test('Dockerfile exists at root', () => {
+  assert.ok(existsSync(DOCKERFILE), 'Dockerfile should exist at project root');
+});
+
+test('Dockerfile has FROM instruction', () => {
+  const content = readFileSync(DOCKERFILE, 'utf8');
+  assert.match(content, /^FROM\s+\S+/m, 'Dockerfile must contain a FROM instruction');
+});
+
+test('Dockerfile has CMD or ENTRYPOINT', () => {
+  const content = readFileSync(DOCKERFILE, 'utf8');
+  assert.ok(
+    /^(CMD|ENTRYPOINT)\s+/m.test(content),
+    'Dockerfile must have a CMD or ENTRYPOINT instruction',
+  );
+});
+
+test('Dockerfile exposes at least one port', () => {
+  const content = readFileSync(DOCKERFILE, 'utf8');
+  assert.match(content, /^EXPOSE\s+\d+/m, 'Dockerfile must expose at least one port');
+});
+
+test('Dockerfile has HEALTHCHECK', () => {
+  const content = readFileSync(DOCKERFILE, 'utf8');
+  assert.match(content, /^HEALTHCHECK\s+/m, 'Dockerfile must have a HEALTHCHECK instruction');
+});
+
+test('Dockerfile uses multi-stage build', () => {
+  const content = readFileSync(DOCKERFILE, 'utf8');
+  const fromCount = content.match(/^FROM\s+\S+/gm);
+  assert.ok(fromCount && fromCount.length >= 2, 'Dockerfile must have at least 2 FROM instructions (multi-stage)');
+});
+
+// ── docker-compose.yml ──────────────────────────────────────────────────────
+
+test('docker-compose.yml exists at root', () => {
+  assert.ok(existsSync(COMPOSE_FILE), 'docker-compose.yml should exist at project root');
+});
+
+test('docker-compose.yml has bizar-dash service with build and ports', () => {
+  const content = readFileSync(COMPOSE_FILE, 'utf8');
+  assert.match(content, /bizar-dash:/, 'docker-compose must define a bizar-dash service');
+  assert.match(content, /build:\s*\./, 'bizar-dash service must have build: .');
+  assert.match(content, /ports:/, 'bizar-dash service must expose ports');
+});
+
+test('docker-compose.yml defines required volumes', () => {
+  const content = readFileSync(COMPOSE_FILE, 'utf8');
+  assert.match(content, /bizar-config:/, 'Must define bizar-config volume');
+  assert.match(content, /bizar-memory:/, 'Must define bizar-memory volume');
+  assert.match(content, /bizar-usage:/, 'Must define bizar-usage volume');
+  assert.match(content, /bizar-backups:/, 'Must define bizar-backups volume');
+});
+
+test('docker-compose.yml has healthcheck', () => {
+  const content = readFileSync(COMPOSE_FILE, 'utf8');
+  assert.match(content, /healthcheck:/, 'bizar-dash service must have a healthcheck');
+});
+
+// ── .dockerignore ───────────────────────────────────────────────────────────
+
+test('.dockerignore exists at root', () => {
+  assert.ok(existsSync(DOCKERIGNORE), '.dockerignore should exist at project root');
+});
+
+test('.dockerignore excludes node_modules and .git', () => {
+  const content = readFileSync(DOCKERIGNORE, 'utf8');
+  assert.match(content, /node_modules/, '.dockerignore must exclude node_modules');
+  assert.match(content, /\.git/, '.dockerignore must exclude .git');
+});

package/bizar-dash/tests/lib/search-fuzzy.test.ts

@@ -0,0 +1,149 @@
+/**
+ * tests/lib/search-fuzzy.test.ts
+ *
+ * v4.9 — Unit tests for fuzzy search with typo tolerance.
+ */
+import { describe, it, expect } from 'vitest';
+import {
+  levenshtein,
+  scoreField,
+  fuzzySearch,
+  type SearchableItem,
+} from '../../src/web/lib/search';
+
+/* ─── Levenshtein ─── */
+
+describe('levenshtein', () => {
+  it('returns 0 for identical strings', () => {
+    expect(levenshtein('hello', 'hello')).toBe(0);
+  });
+
+  it('returns length for completely different strings', () => {
+    expect(levenshtein('abc', 'xyz')).toBe(3);
+  });
+
+  it('counts single-character insertion', () => {
+    expect(levenshtein('cat', 'cats')).toBe(1);
+  });
+
+  it('counts single-character deletion', () => {
+    expect(levenshtein('cats', 'cat')).toBe(1);
+  });
+
+  it('counts single-character substitution', () => {
+    expect(levenshtein('cat', 'car')).toBe(1);
+  });
+
+  it('handles empty strings', () => {
+    expect(levenshtein('', 'abc')).toBe(3);
+    expect(levenshtein('abc', '')).toBe(3);
+    expect(levenshtein('', '')).toBe(0);
+  });
+
+  it('handles transposition as two edits', () => {
+    expect(levenshtein('ab', 'ba')).toBe(2);
+  });
+});
+
+/* ─── scoreField ─── */
+
+describe('scoreField', () => {
+  const field = 'accent color';
+
+  it('exact match scores 100', () => {
+    expect(scoreField('accent color', field)).toBe(100);
+  });
+
+  it('prefix match scores 90', () => {
+    expect(scoreField('acc', field)).toBe(90);
+    expect(scoreField('accent', field)).toBe(90); // starts with "accent"
+  });
+
+  it('word boundary match scores 80', () => {
+    // "color" is a separate word in "accent color"
+    expect(scoreField('color', field)).toBe(80);
+    // "colo" starts at "color" word boundary, not field start
+    expect(scoreField('colo', field)).toBe(80);
+  });
+
+  it('typo within 2 chars scores 40', () => {
+    // "accent" vs "axcent" (one char off)
+    expect(scoreField('axcent', 'accent color')).toBe(40);
+    // "accent" vs "accant" (one char off)
+    const score = scoreField('accant', 'accent color');
+    expect(score).toBe(40);
+  });
+
+  it('substring non-prefix, non-word-boundary match scores 30', () => {
+    // "cent" is not at a word boundary in "accent color"
+    expect(scoreField('cent', 'accent color')).toBe(30);
+  });
+
+  it('returns 0 for no match', () => {
+    expect(scoreField('zzzzz', 'accent color')).toBe(0);
+  });
+
+  it('handles case insensitivity via pre-lowered inputs', () => {
+    // Our callers lower case before passing — verify the scoring works
+    // "accent" is a prefix of "accent color" → scores 90
+    expect(scoreField('Accent'.toLowerCase(), 'Accent Color'.toLowerCase())).toBe(90);
+  });
+});
+
+/* ─── fuzzySearch ─── */
+
+describe('fuzzySearch', () => {
+  const items: SearchableItem[] = [
+    { key: 'theme.accent', label: 'Accent color', section: 'theme', value: '#8b5cf6' },
+    { key: 'theme.fontFamily', label: 'Font family', section: 'theme' },
+    { key: 'ui.layout', label: 'UI layout', section: 'layout', value: 'topnav' },
+    { key: 'defaultAgent', label: 'Default agent', section: 'general', value: 'odin' },
+    { key: 'notifications.onAgentComplete', label: 'Notify on agent complete', section: 'notifications', description: 'Show toast when an agent finishes' },
+  ];
+
+  it('returns empty array for empty query', () => {
+    expect(fuzzySearch('', items)).toEqual([]);
+    expect(fuzzySearch('   ', items)).toEqual([]);
+  });
+
+  it('finds exact match by label', () => {
+    const results = fuzzySearch('accent color', items);
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    expect(results[0].key).toBe('theme.accent');
+    expect(results[0].score).toBe(100);
+  });
+
+  it('finds match by value', () => {
+    const results = fuzzySearch('#8b5cf6', items);
+    expect(results.some((r) => r.key === 'theme.accent')).toBe(true);
+  });
+
+  it('finds match by description', () => {
+    const results = fuzzySearch('toast', items);
+    expect(results.some((r) => r.key === 'notifications.onAgentComplete')).toBe(true);
+  });
+
+  it('finds match via typo tolerance', () => {
+    const results = fuzzySearch('axcent', items);
+    expect(results.some((r) => r.key === 'theme.accent')).toBe(true);
+  });
+
+  it('sorts by score descending', () => {
+    const results = fuzzySearch('agent', items);
+    for (let i = 1; i < results.length; i++) {
+      expect(results[i].score).toBeLessThanOrEqual(results[i - 1].score);
+    }
+  });
+
+  it('returns empty when nothing matches', () => {
+    const results = fuzzySearch('zzzznonexistent', items);
+    expect(results).toEqual([]);
+  });
+
+  it('sets matchedField and matchedTerm on results', () => {
+    const results = fuzzySearch('accent', items);
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].matchedField).toBe('label');
+    expect(results[0].matchedTerm).toBe('Accent color');
+  });
+});

package/bizar-dash/tests/memory-graph-view.test.tsx

@@ -0,0 +1,69 @@
+/**
+ * tests/memory-graph-view.test.tsx
+ *
+ * Tests for MemoryGraphView (SVG force-directed graph).
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import React from 'react';
+import { MemoryGraphView, type GraphData } from '../src/web/views/memory/MemoryGraphView';
+
+const EMPTY_GRAPH: GraphData = { nodes: [], edges: [] };
+
+const THREE_NODE_GRAPH: GraphData = {
+  nodes: [
+    { id: 'notes/alpha.md', label: 'Alpha Note', type: 'note', size: 1, group: 'notes' },
+    { id: 'notes/beta.md', label: 'Beta Note', type: 'note', size: 2, group: 'notes' },
+    { id: 'decisions/dec.md', label: 'Decision', type: 'note', size: 1, group: 'decisions' },
+  ],
+  edges: [
+    { source: 'notes/alpha.md', target: 'notes/beta.md', type: 'links_to', weight: 1 },
+    { source: 'notes/beta.md', target: 'decisions/dec.md', type: 'links_to', weight: 1 },
+  ],
+};
+
+describe('MemoryGraphView', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders SVG with empty graph', () => {
+    render(<MemoryGraphView data={EMPTY_GRAPH} />);
+    const svg = document.querySelector('.memory-graph-canvas');
+    expect(svg).toBeInTheDocument();
+  });
+
+  it('renders nodes and edges', () => {
+    render(<MemoryGraphView data={THREE_NODE_GRAPH} />);
+    // SVG should have circles for nodes (one per node).
+    const circles = document.querySelectorAll('.memory-graph-node');
+    expect(circles.length).toBe(3);
+  });
+
+  it('calls onNodeClick when a node is clicked', () => {
+    const onNodeClick = vi.fn();
+    render(<MemoryGraphView data={THREE_NODE_GRAPH} onNodeClick={onNodeClick} />);
+    const circles = document.querySelectorAll('.memory-graph-node');
+    // Click the first node circle group.
+    if (circles.length > 0) {
+      fireEvent.click(circles[0]);
+    }
+    expect(onNodeClick).toHaveBeenCalledTimes(1);
+  });
+
+  it('renders filtered nodes when filter is applied via data prop', () => {
+    const filteredData = {
+      nodes: THREE_NODE_GRAPH.nodes.filter((n) => n.label.includes('Alpha')),
+      edges: [],
+    };
+    render(<MemoryGraphView data={filteredData} />);
+    const circles = document.querySelectorAll('.memory-graph-node');
+    expect(circles.length).toBe(1);
+  });
+
+  it('node has correct type and group fields', () => {
+    render(<MemoryGraphView data={THREE_NODE_GRAPH} />);
+    const circles = document.querySelectorAll('.memory-graph-node');
+    expect(circles.length).toBeGreaterThan(0);
+  });
+});

package/bizar-dash/tests/memory-graph.test.mjs

@@ -0,0 +1,95 @@
+/**
+ * tests/memory-graph.test.mjs
+ *
+ * Tests for getObsidianLinkGraph in memory-store.mjs
+ * and getLightRAGGraph in memory-lightrag.mjs.
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+
+const TEST_STORE = await import('../src/server/memory-store.mjs').then((m) => m);
+
+describe('getObsidianLinkGraph', () => {
+  let projectRoot;
+
+  beforeEach(() => {
+    projectRoot = join(tmpdir(), `bizar-graph-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+  });
+
+  afterEach(() => {
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  function writeNote(relPath, body) {
+    const full = join(projectRoot, '.obsidian', relPath);
+    mkdirSync(join(projectRoot, '.obsidian', relPath.split('/').slice(0, -1).join('/') || '.'), { recursive: true });
+    const title = relPath.split('/').pop()?.replace(/\.md$/i, '') || relPath;
+    writeFileSync(full, `---\ntitle: ${title}\n---\n\n${body}`, 'utf8');
+  }
+
+  it('extracts wikilinks and builds nodes + edges', () => {
+    writeNote('notes/alpha.md', 'This links to [[Beta Note]] and [[Gamma]].');
+    writeNote('notes/beta.md', 'Back to [[Alpha]].');
+    writeNote('notes/gamma.md', 'No links here.');
+
+    const { nodes, edges } = TEST_STORE.getObsidianLinkGraph({ projectRoot, limit: 200 });
+
+    // Should have 3 nodes.
+    assert.ok(nodes.length >= 3, `Expected >= 3 nodes, got ${nodes.length}`);
+
+    // Each node should have required fields.
+    for (const n of nodes) {
+      assert.ok('id' in n, 'node must have id');
+      assert.ok('label' in n, 'node must have label');
+      assert.ok('type' in n, 'node must have type');
+      assert.ok('size' in n, 'node must have size');
+      assert.ok('group' in n, 'node must have group');
+    }
+
+    // Should have edges.
+    assert.ok(edges.length > 0, 'Expected at least 1 edge');
+    for (const e of edges) {
+      assert.ok('source' in e, 'edge must have source');
+      assert.ok('target' in e, 'edge must have target');
+      assert.ok('type' in e, 'edge must have type');
+      assert.ok('weight' in e, 'edge must have weight');
+    }
+  });
+
+  it('handles empty vault gracefully', () => {
+    const { nodes, edges } = TEST_STORE.getObsidianLinkGraph({ projectRoot, limit: 200 });
+    assert.ok(Array.isArray(nodes), 'nodes must be an array');
+    assert.ok(Array.isArray(edges), 'edges must be an array');
+  });
+
+  it('resolves wikilink targets by basename', () => {
+    writeNote('foo.md', 'See [[Bar]] for details.');
+    writeNote('bar.md', 'Related to [[Foo]].');
+    const { edges } = TEST_STORE.getObsidianLinkGraph({ projectRoot, limit: 200 });
+    // Should have resolved [[Bar]] -> bar.md and [[Foo]] -> foo.md.
+    assert.ok(edges.length >= 1, 'Expected at least 1 edge from wikilink resolution');
+  });
+
+  it('respects the limit parameter', () => {
+    for (let i = 0; i < 10; i++) {
+      writeNote(`note${i}.md`, i === 0 ? 'Links to [[Note1]].' : '');
+    }
+    const { nodes, edges } = TEST_STORE.getObsidianLinkGraph({ projectRoot, limit: 3 });
+    assert.ok(nodes.length <= 3, `Expected <= 3 nodes, got ${nodes.length}`);
+    assert.ok(edges.length <= 9, `Expected <= 9 edges, got ${edges.length}`);
+  });
+
+  it('node label uses title frontmatter when available', () => {
+    writeNote('mydoc.md', 'Content.');
+    const { nodes } = TEST_STORE.getObsidianLinkGraph({ projectRoot, limit: 200 });
+    const mydoc = nodes.find((n) => n.id === 'mydoc.md');
+    assert.ok(mydoc, 'mydoc.md should be a node');
+    assert.strictEqual(mydoc.label, 'mydoc');
+  });
+});

package/bizar-dash/tests/otel.test.mjs

@@ -0,0 +1,188 @@
+/**
+ * tests/otel.test.mjs — v4.9.0
+ *
+ * Tests for src/server/otel.mjs. The OpenTelemetry SDK and helpers
+ * must:
+ *   - export a `tracer` that has `startActiveSpan` (works even before
+ *     `initOtel()` is called, because the no-op global tracer covers
+ *     the uninitialised case)
+ *   - return an SDK instance from `initOtel()` and only initialise
+ *     once across repeated calls
+ *   - shut down cleanly via `shutdownOtel()`, even when the OTLP
+ *     endpoint is unreachable
+ *   - tolerate a malformed endpoint / thrown init error without
+ *     crashing the importing module
+ *
+ * Each test loads the module via a fresh URL to defeat Node's ESM
+ * module cache; `otel.mjs` uses module-scoped state (the `sdk` and
+ * `shuttingDown` lets) and we want each test to see its own clean
+ * registry the same way `metrics.test.mjs` does.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+const OTEL_URL = '../src/server/otel.mjs';
+
+async function loadOtel() {
+  const url = `${OTEL_URL}?v=${Date.now()}-${Math.random()}`;
+  return import(url);
+}
+
+test('tracer is exported and has startActiveSpan', async () => {
+  const otel = await loadOtel();
+  try {
+    assert.equal(typeof otel.tracer, 'object');
+    assert.equal(typeof otel.tracer.startActiveSpan, 'function');
+  } finally {
+    await otel.shutdownOtel();
+  }
+});
+
+test('initOtel() returns an SDK instance and is idempotent', async () => {
+  const otel = await loadOtel();
+  try {
+    // Before init: isOtelEnabled() is false (fresh module load).
+    assert.equal(otel.isOtelEnabled(), false);
+    const sdk1 = otel.initOtel({
+      // Use an endpoint that won't connect; the test only cares
+      // that the SDK object is returned, not that spans export.
+      endpoint: 'http://127.0.0.1:1/v1/traces',
+    });
+    assert.ok(sdk1, 'initOtel should return a non-null SDK instance');
+    assert.equal(otel.isOtelEnabled(), true);
+
+    const sdk2 = otel.initOtel({ endpoint: 'http://127.0.0.1:1/v1/traces' });
+    assert.equal(
+      sdk1,
+      sdk2,
+      'a second initOtel() call must return the cached SDK instance',
+    );
+  } finally {
+    await otel.shutdownOtel();
+  }
+});
+
+test('shutdownOtel() is callable and resets the SDK cache', async () => {
+  const otel = await loadOtel();
+  try {
+    otel.initOtel({ endpoint: 'http://127.0.0.1:1/v1/traces' });
+    assert.equal(otel.isOtelEnabled(), true);
+    await otel.shutdownOtel();
+    assert.equal(otel.isOtelEnabled(), false);
+
+    // Calling shutdownOtel again must be a no-op (does not throw).
+    await otel.shutdownOtel();
+    assert.equal(otel.isOtelEnabled(), false);
+  } finally {
+    await otel.shutdownOtel();
+  }
+});
+
+test('graceful degradation when OTLP endpoint is unreachable', async () => {
+  // Port 1 on loopback never accepts connections — the exporter will
+  // log batch-send errors internally but must not crash the module.
+  const otel = await loadOtel();
+  try {
+    const sdk = otel.initOtel({
+      endpoint: 'http://127.0.0.1:1/v1/traces',
+    });
+    assert.ok(sdk, 'initOtel must succeed even with an unreachable endpoint');
+    assert.equal(otel.isOtelEnabled(), true);
+
+    // Spans created on the live tracer must complete without errors.
+    await new Promise((resolve, reject) => {
+      otel.tracer.startActiveSpan('test.unreachable_endpoint', async (span) => {
+        try {
+          span.setAttribute('test.attr', 1);
+          span.setStatus({ code: 1 /* OK */ });
+          await Promise.resolve();
+          resolve();
+        } catch (e) {
+          reject(e);
+        } finally {
+          span.end();
+        }
+      });
+    });
+
+    await otel.shutdownOtel();
+  } finally {
+    await otel.shutdownOtel();
+  }
+});
+
+test('spans can be created and ended without errors (no SDK initialised)', async () => {
+  // No initOtel call — exercises the no-op tracer path. Route
+  // handlers rely on this when OTEL is disabled (the default).
+  const otel = await loadOtel();
+  assert.equal(otel.isOtelEnabled(), false);
+
+  const result = await new Promise((resolve, reject) => {
+    otel.tracer.startActiveSpan('test.noop', (span) => {
+      try {
+        // Sanity-check that the no-op span still answers every
+        // method without throwing — that's the contract route
+        // handlers rely on.
+        span.setAttribute('a', 1);
+        span.setAttribute('b', 'hello');
+        span.addEvent('event-1');
+        span.setStatus({ code: 1 });
+        resolve('ok');
+      } catch (err) {
+        reject(err);
+      } finally {
+        span.end();
+      }
+    });
+  });
+  assert.equal(result, 'ok');
+
+  await otel.shutdownOtel();
+});
+
+test('tracer.startActiveSpan callback can be async (returns a Promise)', async () => {
+  // The OpenTelemetry spec lets the callback return a Promise;
+  // the tracer awaits it. Make sure the no-op implementation
+  // (used when the SDK is disabled) honors this.
+  const otel = await loadOtel();
+  try {
+    let observed = null;
+    await otel.tracer.startActiveSpan('test.async', async (span) => {
+      try {
+        observed = await Promise.resolve('inside-span');
+      } finally {
+        span.end();
+      }
+    });
+    assert.equal(observed, 'inside-span');
+  } finally {
+    await otel.shutdownOtel();
+  }
+});
+
+test('initOtel accepts custom serviceName override', async () => {
+  const otel = await loadOtel();
+  try {
+    const sdk = otel.initOtel({
+      serviceName: 'bizar-dash-test',
+      endpoint: 'http://127.0.0.1:1/v1/traces',
+    });
+    assert.ok(sdk, 'initOtel with a custom serviceName should succeed');
+    await otel.shutdownOtel();
+  } finally {
+    await otel.shutdownOtel();
+  }
+});
+
+test('module does not crash when imported (no init, no shutdown)', async () => {
+  // Defensive sanity check — every other test file in this repo
+  // transitively imports dozens of modules. If a syntax/import
+  // error sneaks into otel.mjs, this test catches it before the
+  // larger suite blows up somewhere unrelated.
+  const otel = await loadOtel();
+  assert.equal(typeof otel.initOtel, 'function');
+  assert.equal(typeof otel.shutdownOtel, 'function');
+  assert.equal(typeof otel.tracer, 'object');
+  await otel.shutdownOtel();
+});

package/cli/commands/dash.mjs

@@ -42,6 +42,12 @@ export function showDashHelp() {
   Note:
     \`bizar dashboard\` is a deprecated alias for \`bizar dash\` and still
     works, but new code should use \`bizar dash\`.
+
+  OpenTelemetry (optional, env vars):
+    BIZAR_OTEL=1                       Enable OpenTelemetry tracing (off by default)
+    OTEL_ENABLED=1                     Alias that also opts in
+    OTEL_EXPORTER_OTLP_ENDPOINT        OTLP HTTP traces endpoint
+                                       (default http://localhost:4318/v1/traces)
   `);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "4.7.2",
+  "version": "4.9.0",
   "description": "Norse-pantheon multi-agent system for opencode — 13 agents across 4 cost tiers with cost-aware routing, plans, and a configurable agent harness. v4 ships as a single npm package bundling the dashboard server, opencode plugin, and typed SDK.",
   "type": "module",
   "bin": {
@@ -78,6 +78,12 @@
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.17.7",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.52.0",
+    "@opentelemetry/resources": "^1.25.0",
+    "@opentelemetry/sdk-node": "^0.52.0",
+    "@opentelemetry/sdk-trace-node": "^1.25.0",
+    "@opentelemetry/semantic-conventions": "^1.25.0",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",