@polderlabs/bizar 4.4.12 → 4.5.0

package/bizar-dash/tests/skills-list.test.mjs

@@ -0,0 +1,232 @@
+/**
+ * tests/skills-list.test.mjs
+ *
+ * Tests for skills-store.mjs — verifies:
+ * 1. All skill sources are scanned
+ * 2. SKILL.md frontmatter is parsed correctly
+ * 3. Skills have required fields
+ * 4. Cache invalidation works
+ */
+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_ROOT = join(tmpdir(), `bizar-skills-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+
+// Dynamically import so we can set projectRoot before use
+async function getStore() {
+  const { skillsStore, setProjectRoot, invalidateCache } = await import('../src/server/skills-store.mjs');
+  return { skillsStore, setProjectRoot, invalidateCache };
+}
+
+describe('skills-store', () => {
+  let skillsStore;
+  let setProjectRoot;
+  let invalidateCache;
+
+  // Skill directory fixtures
+  let FIXTURE_USER_OPENCODE;
+  let FIXTURE_USER_AGENTS;
+  let FIXTURE_SHIPPED;
+  let FIXTURE_PROJECT;
+
+  beforeEach(async () => {
+    mkdirSync(TEST_ROOT, { recursive: true });
+
+    // Helper: create skill dir + write SKILL.md in one shot
+    const skillFile = (base, name, content) => {
+      const dir = join(base, name);
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(join(dir, 'SKILL.md'), content);
+    };
+
+    // Set up fake shipped directory
+    const shipped = join(TEST_ROOT, 'bizar-dash', 'skills');
+    mkdirSync(shipped, { recursive: true });
+    skillFile(shipped, 'shipped-skill', `---\nname: shipped-display\ndescription: A shipped skill description.\n---\n# Shipped Skill\nBody text.\n`);
+    skillFile(shipped, 'bizar', `---\nname: bizar\ndescription: Bizar main skill.\n---\n# Bizar\nAgent routing.\n`);
+
+    // Set up project-local .agents/skills
+    const projectAgents = join(TEST_ROOT, '.agents', 'skills');
+    mkdirSync(projectAgents, { recursive: true });
+    skillFile(projectAgents, 'project-skill', `---\nname: Project Skill\ndescription: A project-local skill.\n---\n# Project Skill\n`);
+    skillFile(projectAgents, 'chat', `---\nname: chat\ndescription: Chat integration.\n---\n# Chat\n`);
+
+    // Set up project-local .opencode/skills
+    const projectOpencode = join(TEST_ROOT, '.opencode', 'skills');
+    mkdirSync(projectOpencode, { recursive: true });
+    skillFile(projectOpencode, 'usage', `---\nname: usage\ndescription: Usage monitoring.\n---\n# Usage\n`);
+
+    // Set up shipped path (relative to project root)
+    FIXTURE_SHIPPED = shipped;
+
+    const mod = await getStore();
+    skillsStore   = mod.skillsStore;
+    setProjectRoot = mod.setProjectRoot;
+    invalidateCache = mod.invalidateCache;
+
+    setProjectRoot(TEST_ROOT);
+    invalidateCache();
+  });
+
+  afterEach(() => {
+    try { rmSync(TEST_ROOT, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  // ── list() ─────────────────────────────────────────────────────────────────
+
+  describe('list()', () => {
+    it('returns all skills as a flat array', async () => {
+      const all = await skillsStore.list();
+      assert.ok(Array.isArray(all));
+      assert.ok(all.length > 0);
+    });
+
+    it('includes shipped skills from bizar-dash/skills/', async () => {
+      const all = await skillsStore.list();
+      const shipped = all.filter((s) => s.source === 'shipped');
+      assert.ok(shipped.length > 0, 'should have at least one shipped skill');
+      const bizar = shipped.find((s) => s.name === 'bizar');
+      assert.ok(bizar, 'bizar shipped skill should be present');
+    });
+
+    it('includes project-local skills from .agents/skills/', async () => {
+      const all = await skillsStore.list();
+      const project = all.filter((s) => s.source === 'project');
+      assert.ok(project.length > 0, 'should have project skills');
+    });
+
+    it('every skill has name, description, source, path', async () => {
+      const all = await skillsStore.list();
+      for (const s of all) {
+        assert.ok(typeof s.name === 'string' && s.name.length > 0, `${JSON.stringify(s)} needs a name`);
+        assert.ok(typeof s.description === 'string', `${s.name} needs a description string`);
+        assert.ok(['shipped', 'user', 'project'].includes(s.source), `${s.name} needs a valid source`);
+        assert.ok(typeof s.path === 'string' && s.path.endsWith('SKILL.md'), `${s.name} needs a path ending in SKILL.md`);
+      }
+    });
+
+    it('description is truncated to 200 chars', async () => {
+      const long = 'A'.repeat(400);
+      mkdirSync(join(FIXTURE_SHIPPED, 'long-desc'), { recursive: true });
+      writeFileSync(join(FIXTURE_SHIPPED, 'long-desc', 'SKILL.md'), `---\nname: long-desc\ndescription: ${long}\n---\n# Long\n`);
+      invalidateCache();
+      const all = await skillsStore.list();
+      const longSkill = all.find((s) => s.name === 'long-desc');
+      assert.ok(longSkill.description.length <= 200, 'description should be truncated to 200 chars');
+    });
+
+    it('display name falls back to H1 heading when frontmatter name is missing', async () => {
+      mkdirSync(join(FIXTURE_SHIPPED, 'heading-only'), { recursive: true });
+      writeFileSync(join(FIXTURE_SHIPPED, 'heading-only', 'SKILL.md'), `---\ndescription: Has heading but no name field.\n---\n# My Heading Skill\nBody.\n`);
+      invalidateCache();
+      const all = await skillsStore.list();
+      const skill = all.find((s) => s.name === 'My Heading Skill');
+      assert.ok(skill, 'should fall back to H1 heading as name');
+    });
+
+    it('display name falls back to directory name when both frontmatter name and H1 are absent', async () => {
+      mkdirSync(join(FIXTURE_SHIPPED, 'directory-named-skill'), { recursive: true });
+      writeFileSync(join(FIXTURE_SHIPPED, 'directory-named-skill', 'SKILL.md'), `---\ndescription: No name anywhere.\n---\nPlain body without heading.\n`);
+      invalidateCache();
+      const all = await skillsStore.list();
+      const skill = all.find((s) => s.path.endsWith('directory-named-skill/SKILL.md'));
+      assert.ok(skill, 'should fall back to directory name');
+    });
+
+    it('returns empty array when no skill directories exist', async () => {
+      const empty = join(tmpdir(), `bizar-empty-${Date.now()}`);
+      mkdirSync(empty, { recursive: true });
+      setProjectRoot(empty);
+      invalidateCache();
+      const all = await skillsStore.list();
+      assert.ok(Array.isArray(all));
+    });
+  });
+
+  // ── search() ────────────────────────────────────────────────────────────────
+
+  describe('search()', () => {
+    it('returns all skills when query is empty', async () => {
+      const all = await skillsStore.list();
+      const results = await skillsStore.search('');
+      assert.strictEqual(results.length, all.length);
+    });
+
+    it('filters by name or description substring', async () => {
+      const results = await skillsStore.search('bizar');
+      assert.ok(results.length > 0, 'should find at least one skill matching bizar');
+      // Search matches name OR description, so at least one result should contain 'bizar'
+      assert.ok(
+        results.some((s) => `${s.name} ${s.description}`.toLowerCase().includes('bizar')),
+        'results should contain bizar in name or description',
+      );
+    });
+
+    it('filters by description substring', async () => {
+      const results = await skillsStore.search('monitoring');
+      assert.ok(results.length > 0, 'should find skill with monitoring in description');
+    });
+
+    it('returns plain strings — no ANSI escape codes in name or description', async () => {
+      const results = await skillsStore.search('bizar');
+      for (const s of results) {
+        assert.ok(!s.name.includes('\x1b'), `name "${s.name}" should not contain ANSI escape codes`);
+        assert.ok(!s.description.includes('\x1b'), `description should not contain ANSI codes`);
+      }
+    });
+
+    it('matches multi-term queries (AND semantics)', async () => {
+      const results = await skillsStore.search('bizar skill');
+      for (const s of results) {
+        const hay = `${s.name} ${s.description}`.toLowerCase();
+        assert.ok(hay.includes('bizar') && hay.includes('skill'), `${s.name} should match both terms`);
+      }
+    });
+
+    it('is case-insensitive', async () => {
+      const r1 = await skillsStore.search('BIZAR');
+      const r2 = await skillsStore.search('bizar');
+      const r3 = await skillsStore.search('BiZaR');
+      assert.strictEqual(r1.length, r2.length);
+      assert.strictEqual(r2.length, r3.length);
+    });
+  });
+
+  // ── refresh() ─────────────────────────────────────────────────────────────
+
+  describe('refresh()', () => {
+    it('invalidates cache and rescans', async () => {
+      const first = await skillsStore.list();
+      assert.ok(first.length > 0);
+
+      // Add a new skill
+      mkdirSync(join(FIXTURE_SHIPPED, 'brand-new'), { recursive: true });
+      writeFileSync(join(FIXTURE_SHIPPED, 'brand-new', 'SKILL.md'), `---\nname: Brand New\ndescription: A freshly added skill.\n---\n# Brand New\n`);
+      invalidateCache();
+
+      const after = await skillsStore.list();
+      assert.ok(after.length > first.length, 'newly added skill should appear after refresh');
+      const found = after.find((s) => s.name === 'Brand New');
+      assert.ok(found, 'Brand New skill should be in list');
+    });
+  });
+
+  // ── get() ─────────────────────────────────────────────────────────────────
+
+  describe('get()', () => {
+    it('returns a single skill by source and name', async () => {
+      const skill = await skillsStore.get('shipped', 'bizar');
+      assert.ok(skill, 'should find the bizar skill');
+      assert.strictEqual(skill.name, 'bizar');
+      assert.strictEqual(skill.source, 'shipped');
+    });
+
+    it('returns null for unknown skill', async () => {
+      const skill = await skillsStore.get('shipped', 'nonexistent-skill-xyz');
+      assert.strictEqual(skill, null);
+    });
+  });
+});

package/bizar-dash/tests/skills-search.test.mjs

@@ -0,0 +1,222 @@
+/**
+ * tests/skills-search.test.mjs
+ *
+ * Tests for skills search — verifies:
+ * 1. Fuzzy search returns correct matches
+ * 2. NO ASCII garbage / ANSI codes in search results
+ * 3. Multi-term queries work correctly
+ * 4. Empty query returns all skills
+ */
+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_ROOT = join(tmpdir(), `bizar-search-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+
+async function getStore() {
+  const { skillsStore, setProjectRoot, invalidateCache } = await import('../src/server/skills-store.mjs');
+  return { skillsStore, setProjectRoot, invalidateCache };
+}
+
+describe('skills search', () => {
+  let skillsStore;
+  let setProjectRoot;
+  let invalidateCache;
+
+  beforeEach(async () => {
+    mkdirSync(TEST_ROOT, { recursive: true });
+
+    const shipped = join(TEST_ROOT, 'bizar-dash', 'skills');
+    mkdirSync(shipped, { recursive: true });
+
+    // Create test skills with realistic names and descriptions
+    const fixtures = [
+      {
+        dir: 'bizar',
+        name: 'bizar',
+        description: 'Norse-pantheon multi-agent system. Covers Odin routing, agent tiers, cost-aware dispatch.',
+      },
+      {
+        dir: 'agent-baseline',
+        name: 'agent-baseline',
+        description: 'Always-on rules for every Bizar agent. Covers Semble, Skills CLI, loop guard, parallel execution.',
+      },
+      {
+        dir: 'self-improvement',
+        name: 'self-improvement',
+        description: 'Self-improvement protocol. Records lessons to .bizar/AGENTS_SELF_IMPROVEMENT.md.',
+      },
+      {
+        dir: 'obsidian',
+        name: 'obsidian',
+        description: 'Bizar Memory Service using Obsidian-compatible Markdown. Git sync and LightRAG indexing.',
+      },
+      {
+        dir: 'minimax',
+        name: 'minimax',
+        description: 'MiniMax integration. Covers multi-key rotation, usage tracking, rate limits.',
+      },
+      {
+        dir: 'providers',
+        name: 'providers',
+        description: 'Provider subsystem. Backup keys, auto-add wizard, provider catalog management.',
+      },
+      {
+        dir: 'chat',
+        name: 'chat',
+        description: 'Chat and opencode session integration. Real-time SSE streaming, message history.',
+      },
+      {
+        dir: 'usage',
+        name: 'usage',
+        description: 'Token usage monitoring and cost estimation. MiniMax usage dashboard.',
+      },
+      {
+        dir: 'skills-cli',
+        name: 'skills-cli',
+        description: 'Skills CLI reference. Discover and install skills from skills.sh ecosystem.',
+      },
+      {
+        dir: 'lightrag',
+        name: 'lightrag',
+        description: 'LightRAG full-text search integration. Indexing, querying, memory service integration.',
+      },
+    ];
+
+    for (const f of fixtures) {
+      mkdirSync(join(shipped, f.dir), { recursive: true });
+      writeFileSync(
+        join(shipped, f.dir, 'SKILL.md'),
+        `---\nname: ${f.name}\ndescription: ${f.description}\n---\n# ${f.name}\nBody content.\n`,
+      );
+    }
+
+    const mod = await getStore();
+    skillsStore   = mod.skillsStore;
+    setProjectRoot = mod.setProjectRoot;
+    invalidateCache = mod.invalidateCache;
+
+    setProjectRoot(TEST_ROOT);
+    invalidateCache();
+  });
+
+  afterEach(() => {
+    try { rmSync(TEST_ROOT, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  // ── ANSI / ASCII garbage check ──────────────────────────────────────────────
+
+  function assertNoAnsi(label, value) {
+    const ansiPattern = /\x1b\[[0-9;]*[a-zA-Z]/;
+    assert.ok(
+      !ansiPattern.test(value),
+      `${label} should not contain ANSI escape codes: ${JSON.stringify(value.slice(0, 80))}`,
+    );
+  }
+
+  it('search results contain no ANSI escape codes', async () => {
+    const queries = ['', 'bizar', 'skill', 'memory', 'agent', 'provider'];
+    for (const q of queries) {
+      const results = await skillsStore.search(q);
+      for (const s of results) {
+        assertNoAnsi(`name (query="${q}")`, s.name);
+        assertNoAnsi(`description (query="${q}")`, s.description);
+        assertNoAnsi(`path (query="${q}")`, s.path);
+        assertNoAnsi(`source (query="${q}")`, s.source);
+      }
+    }
+  });
+
+  it('list results contain no ANSI escape codes', async () => {
+    const all = await skillsStore.list();
+    for (const s of all) {
+      assertNoAnsi('name', s.name);
+      assertNoAnsi('description', s.description);
+      assertNoAnsi('path', s.path);
+      assertNoAnsi('source', s.source);
+    }
+  });
+
+  it('get() result contains no ANSI escape codes', async () => {
+    const skill = await skillsStore.get('shipped', 'bizar');
+    if (skill) {
+      assertNoAnsi('name', skill.name);
+      assertNoAnsi('description', skill.description);
+    }
+  });
+
+  // ── Search accuracy ─────────────────────────────────────────────────────────
+
+  it('finds skill by name (case-insensitive)', async () => {
+    const results = await skillsStore.search('BIZAR');
+    assert.ok(results.length > 0);
+    assert.ok(results.some((s) => s.name.toLowerCase() === 'bizar'));
+  });
+
+  it('finds skill by partial name', async () => {
+    const results = await skillsStore.search('self-improv');
+    assert.ok(results.length > 0);
+    assert.ok(results.some((s) => s.name === 'self-improvement'));
+  });
+
+  it('finds skill by description keyword', async () => {
+    const results = await skillsStore.search('multi-key rotation');
+    assert.ok(results.length > 0);
+    assert.ok(results.some((s) => s.name === 'minimax'));
+  });
+
+  it('finds skill by description keyword — lightrag', async () => {
+    const results = await skillsStore.search('full-text search');
+    assert.ok(results.length > 0);
+    assert.ok(results.some((s) => s.name === 'lightrag'));
+  });
+
+  it('returns empty array for non-matching query', async () => {
+    const results = await skillsStore.search('zzznonexistent999xyz');
+    assert.ok(Array.isArray(results));
+    assert.strictEqual(results.length, 0);
+  });
+
+  it('multi-term query: both terms must match', async () => {
+    const results = await skillsStore.search('obsidian git');
+    for (const s of results) {
+      const hay = `${s.name} ${s.description}`.toLowerCase();
+      assert.ok(
+        hay.includes('obsidian') && hay.includes('git'),
+        `${s.name} should match both "obsidian" and "git"`,
+      );
+    }
+  });
+
+  it('whitespace-only query returns all', async () => {
+    const all = await skillsStore.list();
+    const results = await skillsStore.search('   ');
+    assert.strictEqual(results.length, all.length);
+  });
+
+  // ── Result shape ────────────────────────────────────────────────────────────
+
+  it('search result has required fields: name, description, source, path', async () => {
+    const results = await skillsStore.search('bizar');
+    assert.ok(results.length > 0);
+    for (const s of results) {
+      assert.ok(typeof s.name === 'string' && s.name.length > 0, 'name required');
+      assert.ok(typeof s.description === 'string', 'description required');
+      assert.ok(['shipped', 'user', 'project'].includes(s.source), 'valid source required');
+      assert.ok(typeof s.path === 'string' && s.path.endsWith('SKILL.md'), 'path required');
+    }
+  });
+
+  it('empty query returns all skills with all fields', async () => {
+    const results = await skillsStore.search('');
+    assert.ok(results.length > 0);
+    for (const s of results) {
+      assert.ok(typeof s.name === 'string');
+      assert.ok(typeof s.description === 'string');
+      assert.ok(typeof s.source === 'string');
+      assert.ok(typeof s.path === 'string');
+    }
+  });
+});

package/bizar-dash/tests/tasks-create.test.mjs

@@ -0,0 +1,187 @@
+/**
+ * tasks-create.test.mjs — tests for POST /api/tasks (no agent selection).
+ *
+ * Run with: node --test bizar-dash/tests/tasks-create.test.mjs
+ *
+ * Strategy: build a minimal Express app with just the tasks router
+ * (mounted on /api). Sandbox HOME so the tasks-store writes to a
+ * tmpdir instead of ~/.config/bizar. Pass an explicit projectId in
+ * every request body so we don't depend on the active project.
+ */
+import { describe, it, before, after, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import express from 'express';
+import { mkdtempSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const REPO = resolve(import.meta.dirname, '..', '..');
+
+let SANDBOX_HOME;
+let ORIGINAL_HOME;
+let app;
+let broadcastEvents;
+let tasksFilePath;
+
+before(async () => {
+  SANDBOX_HOME = mkdtempSync(join(tmpdir(), `bizar-tasks-test-${Date.now()}-`));
+  ORIGINAL_HOME = process.env.HOME;
+  process.env.HOME = SANDBOX_HOME;
+  // tasksStore writes to ~/.config/opencode/projects/<id>/tasks.json
+  // (projects-store.mjs:PROJECTS_DIR).
+  tasksFilePath = join(SANDBOX_HOME, '.config', 'opencode', 'projects', 'test-proj', 'tasks.json');
+});
+
+after(() => {
+  process.env.HOME = ORIGINAL_HOME;
+  try { rmSync(SANDBOX_HOME, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+beforeEach(async () => {
+  broadcastEvents = [];
+  // Reset file between tests so each one starts clean.
+  try { rmSync(tasksFilePath); } catch { /* ignore */ }
+  // Fresh import of the router — build a minimal app.
+  const { createTasksRouter } = await import(
+    `${REPO}/bizar-dash/src/server/routes/tasks.mjs`
+  );
+  app = express();
+  app.use(express.json());
+  app.use('/api', createTasksRouter({
+    state: {},
+    broadcast: (msg) => broadcastEvents.push(msg),
+    projectRoot: SANDBOX_HOME,
+  }));
+});
+
+async function request(method, path, body) {
+  const http = await import('node:http');
+  return new Promise((resolveP, reject) => {
+    const server = app.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      const bodyStr = body ? JSON.stringify(body) : '';
+      const req = http.request({
+        hostname: '127.0.0.1',
+        port,
+        path,
+        method,
+        headers: bodyStr
+          ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(bodyStr) }
+          : {},
+      }, (res) => {
+        let data = '';
+        res.on('data', (c) => { data += c; });
+        res.on('end', () => {
+          server.close();
+          try {
+            resolveP({ status: res.statusCode, body: JSON.parse(data) });
+          } catch {
+            resolveP({ status: res.statusCode, body: data });
+          }
+        });
+      });
+      req.on('error', (err) => { server.close(); reject(err); });
+      if (bodyStr) req.write(bodyStr);
+      req.end();
+    });
+  });
+}
+
+describe('POST /api/tasks — simplified create flow (no agent selection)', () => {
+  it('creates a task with just title + description, returning 201', async () => {
+    const res = await request('POST', '/api/tasks', {
+      projectId: 'test-proj',
+      title: 'Test task',
+      description: 'A simple task without any agent field.',
+    });
+    assert.equal(res.status, 201, `expected 201, got ${res.status}: ${JSON.stringify(res.body)}`);
+    assert.ok(res.body.id, 'response should include id');
+    assert.equal(res.body.title, 'Test task');
+    assert.equal(res.body.description, 'A simple task without any agent field.');
+  });
+
+  it('does not store any agent-related field when none is provided', async () => {
+    const res = await request('POST', '/api/tasks', {
+      projectId: 'test-proj',
+      title: 'No agent task',
+      description: 'Just title and description.',
+    });
+    assert.equal(res.status, 201);
+    // The store does not have an `agent` field — it has `assignee`
+    // and `workedBy`. Both must be null/empty since no agent was picked.
+    assert.equal(res.body.assignee, null, 'assignee should be null when not provided');
+    assert.equal(res.body.workedBy, null, 'workedBy should be null when not provided');
+    // Defensive: no field literally named `agent` should leak through.
+    assert.equal(res.body.agent, undefined, 'response should not have an `agent` field');
+  });
+
+  it('still respects an explicitly passed assignee (backward compat)', async () => {
+    // The store API has always accepted `assignee`. We don't break it —
+    // we just don't ask for it in the simplified UI. Tests that callers
+    // can still set it explicitly when they want to.
+    const res = await request('POST', '/api/tasks', {
+      projectId: 'test-proj',
+      title: 'Manually assigned',
+      description: 'Caller passed assignee explicitly.',
+      assignee: 'odin',
+    });
+    assert.equal(res.status, 201);
+    assert.equal(res.body.assignee, 'odin');
+  });
+
+  it('ignores an unrecognized `agent` field (does not store it)', async () => {
+    const res = await request('POST', '/api/tasks', {
+      projectId: 'test-proj',
+      title: 'With unknown field',
+      description: 'Caller passed agent field by mistake.',
+      agent: 'thor',
+    });
+    assert.equal(res.status, 201);
+    // The store doesn't have an `agent` field. Any incoming `agent`
+    // is just an unknown prop and should not appear on the stored task.
+    assert.equal(res.body.agent, undefined, 'agent field should not be stored');
+    assert.equal(res.body.assignee, null, 'assignee should remain null');
+  });
+
+  it('persists the task to disk with no agent data', async () => {
+    const res = await request('POST', '/api/tasks', {
+      projectId: 'test-proj',
+      title: 'Persisted',
+      description: 'Check disk state.',
+    });
+    assert.equal(res.status, 201);
+
+    assert.ok(existsSync(tasksFilePath), 'tasks.json should be written to disk');
+    const stored = JSON.parse(readFileSync(tasksFilePath, 'utf8'));
+    assert.equal(stored.tasks.length, 1);
+    const task = stored.tasks[0];
+    assert.equal(task.title, 'Persisted');
+    assert.equal(task.assignee, null);
+    assert.equal(task.workedBy, null);
+    assert.equal(task.agent, undefined);
+  });
+
+  it('rejects create without a title (non-201 with title-related error)', async () => {
+    const res = await request('POST', '/api/tasks', {
+      projectId: 'test-proj',
+      description: 'No title — should fail.',
+    });
+    assert.notEqual(res.status, 201, 'should not succeed without a title');
+    assert.ok(
+      res.body.message?.toLowerCase().includes('title'),
+      `error message should mention title, got: ${JSON.stringify(res.body)}`,
+    );
+  });
+
+  it('emits a tasks:change broadcast event', async () => {
+    const res = await request('POST', '/api/tasks', {
+      projectId: 'test-proj',
+      title: 'Broadcast test',
+      description: 'Should fire tasks:change.',
+    });
+    assert.equal(res.status, 201);
+    assert.equal(broadcastEvents.length, 1, 'should emit exactly one event');
+    assert.equal(broadcastEvents[0].type, 'tasks:change');
+    assert.equal(broadcastEvents[0].task.title, 'Broadcast test');
+  });
+});