groove-dev 0.27.182 → 0.27.184

package/node_modules/@groove-dev/daemon/test/innerchat.test.js

@@ -3,201 +3,260 @@
 
 import { describe, it, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { InnerChat } from '../src/innerchat.js';
+import { InnerChat, MAX_EXCHANGES } from '../src/innerchat.js';
 
+// Mirrors the daemon surface deliverInstruction touches. `_loops` marks an
+// interactive loop, `_running` a busy CLI agent; anything in neither is
+// stopped (resume path, which mints a new id).
 function makeDaemon() {
   const broadcasts = [];
   const audits = [];
-  const sentMessages = [];
-  const queuedMessages = [];
+  const sent = [];
+  const queued = [];
+  const resumes = [];
+  let idCounter = 0;
 
   return {
-    broadcasts,
-    audits,
-    sentMessages,
-    queuedMessages,
+    broadcasts, audits, sent, queued, resumes,
     registry: {
       _agents: new Map(),
       get(id) { return this._agents.get(id) || null; },
-      add(agent) { this._agents.set(agent.id, agent); },
+      getAll() { return [...this._agents.values()]; },
+      add(agent) { this._agents.set(agent.id, agent); return agent; },
+      remove(id) { this._agents.delete(id); },
+      flushPendingRemovals() {},
+      update() {},
     },
+    locks: { release() {} },
     processes: {
       _loops: new Set(),
       _running: new Set(),
       hasAgentLoop(id) { return this._loops.has(id); },
       isRunning(id) { return this._running.has(id); },
-      async sendMessage(id, msg, source) {
-        sentMessages.push({ id, msg, source });
-        return true;
-      },
-      queueMessage(id, msg) {
-        queuedMessages.push({ id, msg });
+      async sendMessage(id, msg) { sent.push({ id, msg }); return true; },
+      queueMessage(id, msg) { queued.push({ id, msg }); },
+      async resume(id, msg) {
+        const old = this._agentsRef.get(id);
+        const fresh = { ...old, id: `${id}-r${++idCounter}` };
+        this._agentsRef.delete(id);
+        this._agentsRef.set(fresh.id, fresh);
+        resumes.push({ id, msg, newId: fresh.id });
+        return fresh;
       },
     },
+    rotator: {
+      async rotate(id, opts) { return this._daemon.processes.resume(id, opts.additionalPrompt); },
+    },
     broadcast(msg) { broadcasts.push(msg); },
     audit: { log(type, data) { audits.push({ type, data }); } },
   };
 }
 
+const result = (text) => ({ type: 'result', data: text });
+const tick = () => new Promise((r) => setImmediate(r));
+
 describe('InnerChat', () => {
-  let daemon;
-  let innerchat;
+  let daemon, innerchat;
 
   beforeEach(() => {
     daemon = makeDaemon();
+    daemon.processes._agentsRef = daemon.registry._agents;
+    daemon.rotator._daemon = daemon;
     innerchat = new InnerChat(daemon);
     daemon.innerchat = innerchat;
 
-    daemon.registry.add({ id: 'a1', name: 'fullstack-1', role: 'fullstack' });
-    daemon.registry.add({ id: 'a2', name: 'fullstack-14', role: 'fullstack' });
-    daemon.processes._loops.add('a2');
-    daemon.processes._running.add('a2');
+    for (const [id, name] of [['a1', 'fullstack-1'], ['a2', 'fullstack-14']]) {
+      daemon.registry.add({ id, name, role: 'fullstack', provider: 'claude-code' });
+      daemon.processes._loops.add(id);
+      daemon.processes._running.add(id);
+    }
   });
 
-  it('should send a message between agents', async () => {
-    const msg = await innerchat.send('a1', 'a2', 'What endpoint shape are you using?');
-    assert.ok(msg.id);
-    assert.equal(msg.from.id, 'a1');
-    assert.equal(msg.from.name, 'fullstack-1');
-    assert.equal(msg.to.id, 'a2');
-    assert.equal(msg.to.name, 'fullstack-14');
-    assert.equal(msg.message, 'What endpoint shape are you using?');
-    assert.equal(msg.response, null);
-    assert.equal(msg.status, 'delivered');
-  });
+  // ── The blocking round trip ───────────────────────────────
 
-  it('should deliver via sendMessage when agent has loop', async () => {
-    await innerchat.send('a1', 'a2', 'Hello');
-    assert.equal(daemon.sentMessages.length, 1);
-    assert.equal(daemon.sentMessages[0].id, 'a2');
-    assert.ok(daemon.sentMessages[0].msg.includes('InnerChat from fullstack-1'));
-    assert.ok(daemon.sentMessages[0].msg.includes('Hello'));
-  });
+  it('blocks until the target answers, then resolves with the reply', async () => {
+    const pending = innerchat.ask('a1', 'a2', 'What endpoint shape?');
 
-  it('should queue when agent is running but no loop', async () => {
-    daemon.processes._loops.delete('a2');
-    await innerchat.send('a1', 'a2', 'Hello');
-    assert.equal(daemon.queuedMessages.length, 1);
-    assert.equal(daemon.queuedMessages[0].id, 'a2');
+    let settled = false;
+    pending.then(() => { settled = true; });
+    await tick();
+    assert.equal(settled, false, 'must not resolve before an answer arrives');
+
+    const delivered = daemon.sent.at(-1);
+    assert.equal(delivered.id, 'a2');
+    assert.match(delivered.msg, /fullstack-1 \(fullstack\) is asking you a question/);
+    assert.match(delivered.msg, /BLOCKED waiting on your answer/);
+
+    innerchat.onAgentOutput('a2', result('REST, /api/v2/orders'));
+    const res = await pending;
+
+    assert.equal(res.reply, 'REST, /api/v2/orders');
+    assert.equal(res.exchanges, 1);
+    assert.equal(res.remaining, MAX_EXCHANGES - 1);
   });
 
-  it('should throw when target agent is not running', async () => {
-    daemon.processes._running.delete('a2');
-    daemon.processes._loops.delete('a2');
-    await assert.rejects(() => innerchat.send('a1', 'a2', 'Hello'), /not running/);
+  it('ignores non-result and empty output while waiting', async () => {
+    const pending = innerchat.ask('a1', 'a2', 'What shape?');
+    await tick();
+
+    innerchat.onAgentOutput('a2', { type: 'assistant', data: 'thinking…' });
+    innerchat.onAgentOutput('a2', result('   '));
+    await tick();
+
+    assert.ok(innerchat.getPending('a2'), 'still waiting');
+    innerchat.onAgentOutput('a2', result('done'));
+    assert.equal((await pending).reply, 'done');
   });
 
-  it('should throw when sender does not exist', async () => {
-    await assert.rejects(() => innerchat.send('unknown', 'a2', 'Hello'), /not found/);
+  it('skips the in-flight result when the question queued behind live work', async () => {
+    daemon.processes._loops.delete('a2'); // running, no loop → queued
+    const pending = innerchat.ask('a1', 'a2', 'What shape?');
+    await tick();
+    assert.equal(daemon.queued.at(-1).id, 'a2');
+
+    innerchat.onAgentOutput('a2', result('finished the PREVIOUS task'));
+    await tick();
+    assert.ok(innerchat.getPending('a2'), 'prior task result must not be taken as the answer');
+
+    innerchat.onAgentOutput('a2', result('the actual answer'));
+    assert.equal((await pending).reply, 'the actual answer');
   });
 
-  it('should throw when sending to self', async () => {
-    // The route validates this, but let's verify it's caught
-    daemon.processes._loops.add('a1');
-    daemon.processes._running.add('a1');
-    const msg = await innerchat.send('a1', 'a1', 'Hello');
-    assert.ok(msg.id);
+  // ── Guardrails ────────────────────────────────────────────
+
+  it('refuses a call that would deadlock and says how to resolve it', async () => {
+    const outbound = innerchat.ask('a1', 'a2', 'question for 14');
+    await tick();
+
+    // a2 tries to ask a1 back while a1 is blocked on a2.
+    await assert.rejects(
+      () => innerchat.ask('a2', 'a1', 'counter-question'),
+      /waiting for YOUR answer/,
+    );
+
+    innerchat.onAgentOutput('a2', result('fine'));
+    await outbound;
   });
 
-  it('should broadcast innerchat:sent on send', async () => {
-    await innerchat.send('a1', 'a2', 'Hello');
-    const sent = daemon.broadcasts.find(b => b.type === 'innerchat:sent');
-    assert.ok(sent);
-    assert.equal(sent.data.message, 'Hello');
+  it('refuses a second concurrent question to a busy target', async () => {
+    daemon.registry.add({ id: 'a3', name: 'fullstack-9', role: 'fullstack', provider: 'claude-code' });
+    daemon.processes._loops.add('a3');
+    daemon.processes._running.add('a3');
+
+    const first = innerchat.ask('a1', 'a2', 'q1');
+    await tick();
+    await assert.rejects(() => innerchat.ask('a3', 'a2', 'q2'), /already answering/);
+
+    innerchat.onAgentOutput('a2', result('a'));
+    await first;
   });
 
-  it('should capture response on agent output', async () => {
-    const msg = await innerchat.send('a1', 'a2', 'What shape?');
-    innerchat.onAgentOutput('a2', { type: 'result', data: 'GET /api/projects/:id returns { id, name }' });
-    assert.equal(msg.status, 'responded');
-    assert.equal(msg.response, 'GET /api/projects/:id returns { id, name }');
-    assert.ok(msg.respondedAt);
+  it('enforces the exchange cap and tells the agent to report', async () => {
+    for (let i = 0; i < MAX_EXCHANGES; i++) {
+      const p = innerchat.ask('a1', 'a2', `q${i}`);
+      await tick();
+      innerchat.onAgentOutput('a2', result(`a${i}`));
+      await p;
+    }
+    await assert.rejects(
+      () => innerchat.ask('a1', 'a2', 'one more'),
+      new RegExp(`${MAX_EXCHANGES}-exchange limit`),
+    );
   });
 
-  it('should relay response back to sender', async () => {
-    daemon.processes._loops.add('a1');
-    daemon.processes._running.add('a1');
-    await innerchat.send('a1', 'a2', 'What shape?');
-    daemon.sentMessages.length = 0;
-
-    innerchat.onAgentOutput('a2', { type: 'result', data: 'The answer' });
-    assert.equal(daemon.sentMessages.length, 1);
-    assert.equal(daemon.sentMessages[0].id, 'a1');
-    assert.ok(daemon.sentMessages[0].msg.includes('InnerChat reply from fullstack-14'));
-    assert.ok(daemon.sentMessages[0].msg.includes('The answer'));
+  it('counts exchanges down across a continuing conversation', async () => {
+    const p1 = innerchat.ask('a1', 'a2', 'q1');
+    await tick(); innerchat.onAgentOutput('a2', result('a1'));
+    const r1 = await p1;
+
+    const p2 = innerchat.ask('a1', 'a2', 'q2');
+    await tick(); innerchat.onAgentOutput('a2', result('a2'));
+    const r2 = await p2;
+
+    assert.equal(r1.threadId, r2.threadId, 'same conversation continues');
+    assert.equal(r2.exchanges, 2);
+    assert.equal(r2.remaining, MAX_EXCHANGES - 2);
   });
 
-  it('should ignore non-result output', async () => {
-    await innerchat.send('a1', 'a2', 'What shape?');
-    innerchat.onAgentOutput('a2', { type: 'activity', subtype: 'stream', data: 'partial...' });
-    const msg = innerchat.getMessage(innerchat.getMessages()[0].id);
-    assert.equal(msg.status, 'delivered');
-    assert.equal(msg.response, null);
+  it('times out rather than blocking forever', async () => {
+    await assert.rejects(
+      () => innerchat.ask('a1', 'a2', 'silence', { timeoutMs: 20 }),
+      /No answer within/,
+    );
+    // The slot must be released, or the pair is wedged for good.
+    assert.equal(innerchat.getPending('a2'), null);
+    assert.equal(innerchat.blockedOn.get('a1'), undefined);
   });
 
-  it('should ignore output from agents with no pending question', () => {
-    innerchat.onAgentOutput('a2', { type: 'result', data: 'Some output' });
-    assert.equal(daemon.broadcasts.length, 0);
+  it('unblocks the asker when the target dies mid-question', async () => {
+    const pending = innerchat.ask('a1', 'a2', 'q');
+    await tick();
+    innerchat.onAgentGone('a2', 'crashed');
+    await assert.rejects(() => pending, /crashed before answering/);
+    assert.equal(innerchat.blockedOn.get('a1'), undefined);
   });
 
-  it('should extract text from array-format output', async () => {
-    await innerchat.send('a1', 'a2', 'Hello');
-    innerchat.onAgentOutput('a2', {
-      type: 'result',
-      data: [
-        { type: 'text', text: 'Part 1' },
-        { type: 'tool_use', name: 'Read', input: {} },
-        { type: 'text', text: 'Part 2' },
-      ],
-    });
-    const msg = innerchat.getMessages()[0];
-    assert.equal(msg.response, 'Part 1\nPart 2');
+  it('rejects unknown, self-addressed and empty asks', async () => {
+    await assert.rejects(() => innerchat.ask('nope', 'a2', 'x'), /not found/);
+    await assert.rejects(() => innerchat.ask('a1', 'nope', 'x'), /not found/);
+    await assert.rejects(() => innerchat.ask('a1', 'a1', 'x'), /cannot ask itself/);
+    await assert.rejects(() => innerchat.ask('a1', 'a2', '  '), /message is required/);
   });
 
-  it('should broadcast innerchat:response on response', async () => {
-    await innerchat.send('a1', 'a2', 'Hello');
-    innerchat.onAgentOutput('a2', { type: 'result', data: 'Response here' });
-    const resp = daemon.broadcasts.find(b => b.type === 'innerchat:response');
-    assert.ok(resp);
-    assert.equal(resp.data.response, 'Response here');
+  it('surfaces a delivery failure as an unreachable error', async () => {
+    daemon.processes.sendMessage = async () => { throw new Error('pipe closed'); };
+    await assert.rejects(() => innerchat.ask('a1', 'a2', 'x'), /Could not reach fullstack-14: pipe closed/);
+    assert.equal(innerchat.blockedOn.get('a1'), undefined);
   });
 
-  it('should list messages filtered by agent', async () => {
-    daemon.processes._loops.add('a1');
-    daemon.processes._running.add('a1');
-    daemon.registry.add({ id: 'a3', name: 'backend-1', role: 'backend' });
-    daemon.processes._loops.add('a3');
-    daemon.processes._running.add('a3');
+  // ── Stopped targets / id remapping ────────────────────────
+
+  it('resumes a stopped target and matches the answer on its new id', async () => {
+    daemon.processes._loops.delete('a2');
+    daemon.processes._running.delete('a2');
 
-    await innerchat.send('a1', 'a2', 'Message 1');
-    await innerchat.send('a1', 'a3', 'Message 2');
+    const pending = innerchat.ask('a1', 'a2', 'ping');
+    await tick();
 
-    assert.equal(innerchat.getMessages().length, 2);
-    assert.equal(innerchat.getMessages('a2').length, 1);
-    assert.equal(innerchat.getMessages('a3').length, 1);
-    assert.equal(innerchat.getMessages('a1').length, 2);
-  });
+    const newId = daemon.resumes.at(-1).newId;
+    assert.notEqual(newId, 'a2');
+    assert.equal(innerchat.getPending('a2'), null, 'old id no longer tracked');
+    assert.ok(innerchat.getPending(newId), 'awaited on the new id');
 
-  it('should return pending question for agent', async () => {
-    assert.equal(innerchat.getPending('a2'), null);
-    await innerchat.send('a1', 'a2', 'Question?');
-    const pending = innerchat.getPending('a2');
-    assert.ok(pending);
-    assert.equal(pending.message, 'Question?');
+    innerchat.onAgentOutput(newId, result('pong'));
+    assert.equal((await pending).reply, 'pong');
   });
 
-  it('should clear pending after response', async () => {
-    await innerchat.send('a1', 'a2', 'Question?');
-    innerchat.onAgentOutput('a2', { type: 'result', data: 'Answer' });
-    assert.equal(innerchat.getPending('a2'), null);
+  // ── Conversation context ──────────────────────────────────
+
+  it('replays prior turns so neither side re-explains', async () => {
+    const p1 = innerchat.ask('a1', 'a2', 'What shape?');
+    await tick(); innerchat.onAgentOutput('a2', result('REST'));
+    await p1;
+
+    const p2 = innerchat.ask('a1', 'a2', 'Versioned?');
+    await tick();
+    const msg = daemon.sent.at(-1).msg;
+    assert.match(msg, /Earlier in this conversation/);
+    assert.match(msg, /fullstack-1: What shape\?/);
+    assert.match(msg, /fullstack-14: REST/);
+    assert.match(msg, /Versioned\?/);
+
+    innerchat.onAgentOutput('a2', result('v2'));
+    await p2;
   });
 
-  it('should audit send and response events', async () => {
-    await innerchat.send('a1', 'a2', 'Hello');
-    innerchat.onAgentOutput('a2', { type: 'result', data: 'Reply' });
-    const sendAudit = daemon.audits.find(a => a.type === 'innerchat.send');
-    const respAudit = daemon.audits.find(a => a.type === 'innerchat.response');
-    assert.ok(sendAudit);
-    assert.ok(respAudit);
+  it('broadcasts and audits both directions', async () => {
+    const p = innerchat.ask('a1', 'a2', 'q');
+    await tick();
+    innerchat.onAgentOutput('a2', result('a'));
+    await p;
+
+    const turns = daemon.broadcasts.filter((b) => b.type === 'innerchat:turn');
+    assert.equal(turns.length, 2);
+    assert.equal(turns[0].data.turn.kind, 'ask');
+    assert.equal(turns[1].data.turn.kind, 'answer');
+    assert.ok(daemon.audits.some((a) => a.type === 'innerchat.ask'));
+    assert.ok(daemon.audits.some((a) => a.type === 'innerchat.answer'));
   });
 });

package/node_modules/@groove-dev/daemon/test/rename.test.js

@@ -0,0 +1,108 @@
+// GROOVE — Agent Rename Migration Tests
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, readFileSync, rmSync } from 'fs';
+import { resolve } from 'path';
+import { tmpdir } from 'os';
+import { renameAgent } from '../src/rename.js';
+import { Registry } from '../src/registry.js';
+
+describe('renameAgent', () => {
+  let root, daemon, agent;
+
+  beforeEach(() => {
+    root = mkdtempSync(resolve(tmpdir(), 'groove-rename-'));
+    const grooveDir = resolve(root, '.groove');
+    mkdirSync(resolve(grooveDir, 'logs'), { recursive: true });
+    mkdirSync(resolve(grooveDir, 'personalities'), { recursive: true });
+    mkdirSync(resolve(root, 'agent-files'), { recursive: true });
+
+    const registry = new Registry({ save() {}, load() { return null; } });
+    daemon = {
+      registry,
+      grooveDir,
+      projectDir: root,
+      audit: { log() {} },
+    };
+    agent = registry.add({ role: 'fullstack', name: 'fullstack-1' });
+
+    writeFileSync(resolve(grooveDir, 'logs', 'fullstack-1.log'), 'session history');
+    writeFileSync(resolve(grooveDir, 'personalities', 'fullstack-1.md'), 'be terse');
+    mkdirSync(resolve(root, 'agent-files', 'fullstack-1'));
+    writeFileSync(resolve(root, 'agent-files', 'fullstack-1', 'notes.md'), 'notes');
+  });
+
+  afterEach(() => rmSync(root, { recursive: true, force: true }));
+
+  const p = {
+    log: (n) => resolve(root, '.groove', 'logs', `${n}.log`),
+    personality: (n) => resolve(root, '.groove', 'personalities', `${n}.md`),
+    files: (n) => resolve(root, 'agent-files', n),
+  };
+
+  it('migrates the log, personality and agent-files', () => {
+    renameAgent(daemon, agent.id, 'senior-dev');
+
+    assert.equal(daemon.registry.get(agent.id).name, 'senior-dev');
+
+    assert.ok(!existsSync(p.log('fullstack-1')), 'old log removed');
+    assert.equal(readFileSync(p.log('senior-dev'), 'utf8'), 'session history');
+
+    assert.ok(!existsSync(p.personality('fullstack-1')));
+    assert.equal(readFileSync(p.personality('senior-dev'), 'utf8'), 'be terse');
+
+    assert.ok(!existsSync(p.files('fullstack-1')));
+    assert.equal(readFileSync(resolve(p.files('senior-dev'), 'notes.md'), 'utf8'), 'notes');
+  });
+
+  it('rejects a name already taken by another agent', () => {
+    daemon.registry.add({ role: 'fullstack', name: 'fullstack-2' });
+    assert.throws(() => renameAgent(daemon, agent.id, 'fullstack-2'), /already exists/);
+
+    // Nothing moved — the original log must survive a rejected rename.
+    assert.equal(daemon.registry.get(agent.id).name, 'fullstack-1');
+    assert.equal(readFileSync(p.log('fullstack-1'), 'utf8'), 'session history');
+  });
+
+  it('rejects an empty name and no-ops an unchanged one', () => {
+    assert.throws(() => renameAgent(daemon, agent.id, '   '), /name is required/);
+    const same = renameAgent(daemon, agent.id, 'fullstack-1');
+    assert.equal(same.name, 'fullstack-1');
+    assert.equal(readFileSync(p.log('fullstack-1'), 'utf8'), 'session history');
+  });
+
+  it('throws for an unknown agent', () => {
+    assert.throws(() => renameAgent(daemon, 'nope', 'whatever'), /Agent not found/);
+  });
+
+  it('tolerates missing artifacts', () => {
+    rmSync(p.personality('fullstack-1'));
+    rmSync(p.files('fullstack-1'), { recursive: true });
+
+    renameAgent(daemon, agent.id, 'solo');
+    assert.equal(readFileSync(p.log('solo'), 'utf8'), 'session history');
+    assert.ok(!existsSync(p.personality('solo')));
+  });
+
+  it('rejects names that would escape their directory', () => {
+    // These become path segments (agent-files/<name>), so a separator or a
+    // dot-segment would write outside the intended directory.
+    for (const bad of ['front end/dev', '../escape', '..', 'a/../../b', 'has space']) {
+      assert.throws(() => renameAgent(daemon, agent.id, bad), /name may only contain|name must be/);
+    }
+    assert.equal(daemon.registry.get(agent.id).name, 'fullstack-1');
+    assert.ok(existsSync(p.log('fullstack-1')));
+  });
+
+  it('rejects an over-long name', () => {
+    assert.throws(() => renameAgent(daemon, agent.id, 'x'.repeat(65)), /64 characters/);
+  });
+
+  it('blocks a bare registry.update from renaming without migration', () => {
+    daemon.registry.update(agent.id, { name: 'sneaky' });
+    assert.equal(daemon.registry.get(agent.id).name, 'fullstack-1');
+    assert.ok(existsSync(p.log('fullstack-1')), 'log was never orphaned');
+  });
+});

package/node_modules/@groove-dev/daemon/test/teams.test.js

@@ -185,6 +185,59 @@ describe('Teams', () => {
     assert.ok(teams2.list().some((t) => t.name === 'Persistent'));
   });
 
+  describe('reorder', () => {
+    it('reorders the list and persists it', () => {
+      const a = teams.create('Alpha');
+      const b = teams.create('Bravo');
+      const c = teams.create('Charlie');
+      const def = teams.getDefault();
+
+      teams.reorder([c.id, a.id, b.id, def.id]);
+      assert.deepEqual(teams.list().map((t) => t.name), ['Charlie', 'Alpha', 'Bravo', 'Default']);
+
+      // Order is the persisted array order, so it survives a reload.
+      const reloaded = new Teams(daemon);
+      assert.deepEqual(reloaded.list().map((t) => t.name), ['Charlie', 'Alpha', 'Bravo', 'Default']);
+    });
+
+    it('keeps teams missing from the given order rather than dropping them', () => {
+      const a = teams.create('Alpha');
+      const b = teams.create('Bravo');
+      const before = teams.list().length;
+
+      // A stale client sends only the ids it knew about.
+      teams.reorder([b.id, a.id]);
+
+      assert.equal(teams.list().length, before);
+      assert.deepEqual(teams.list().map((t) => t.name), ['Bravo', 'Alpha', 'Default']);
+    });
+
+    it('ignores unknown and duplicated ids', () => {
+      const a = teams.create('Alpha');
+      const before = teams.list().length;
+
+      teams.reorder([a.id, 'does-not-exist', a.id]);
+
+      assert.equal(teams.list().length, before);
+      assert.equal(teams.list()[0].name, 'Alpha');
+    });
+
+    it('rejects a non-array', () => {
+      assert.throws(() => teams.reorder('nope'), /must be an array/);
+      assert.throws(() => teams.reorder(undefined), /must be an array/);
+    });
+
+    it('broadcasts the new order', () => {
+      const a = teams.create('Alpha');
+      broadcasts.length = 0;
+      teams.reorder([a.id]);
+
+      const evt = broadcasts.find((b) => b.type === 'teams:reordered');
+      assert.ok(evt, 'teams:reordered was broadcast');
+      assert.equal(evt.teams[0].name, 'Alpha');
+    });
+  });
+
   it('should provide backward compat stubs', () => {
     // onAgentChange is a no-op
     teams.onAgentChange();